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        if !self.distribution_keys.is_empty() {
2339            len += 1;
2340        }
2341        let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2342        if self.need_op {
2343            struct_ser.serialize_field("needOp", &self.need_op)?;
2344        }
2345        if !self.distribution_keys.is_empty() {
2346            struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2347        }
2348        struct_ser.end()
2349    }
2350}
2351impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2352    #[allow(deprecated)]
2353    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2354    where
2355        D: serde::Deserializer<'de>,
2356    {
2357        const FIELDS: &[&str] = &[
2358            "need_op",
2359            "needOp",
2360            "distribution_keys",
2361            "distributionKeys",
2362        ];
2363
2364        #[allow(clippy::enum_variant_names)]
2365        enum GeneratedField {
2366            NeedOp,
2367            DistributionKeys,
2368        }
2369        impl<'de> serde::Deserialize<'de> for GeneratedField {
2370            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2371            where
2372                D: serde::Deserializer<'de>,
2373            {
2374                struct GeneratedVisitor;
2375
2376                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2377                    type Value = GeneratedField;
2378
2379                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2380                        write!(formatter, "expected one of: {:?}", &FIELDS)
2381                    }
2382
2383                    #[allow(unused_variables)]
2384                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2385                    where
2386                        E: serde::de::Error,
2387                    {
2388                        match value {
2389                            "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2390                            "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2391                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2392                        }
2393                    }
2394                }
2395                deserializer.deserialize_identifier(GeneratedVisitor)
2396            }
2397        }
2398        struct GeneratedVisitor;
2399        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2400            type Value = ChangeLogNode;
2401
2402            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2403                formatter.write_str("struct stream_plan.ChangeLogNode")
2404            }
2405
2406            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2407                where
2408                    V: serde::de::MapAccess<'de>,
2409            {
2410                let mut need_op__ = None;
2411                let mut distribution_keys__ = None;
2412                while let Some(k) = map_.next_key()? {
2413                    match k {
2414                        GeneratedField::NeedOp => {
2415                            if need_op__.is_some() {
2416                                return Err(serde::de::Error::duplicate_field("needOp"));
2417                            }
2418                            need_op__ = Some(map_.next_value()?);
2419                        }
2420                        GeneratedField::DistributionKeys => {
2421                            if distribution_keys__.is_some() {
2422                                return Err(serde::de::Error::duplicate_field("distributionKeys"));
2423                            }
2424                            distribution_keys__ = 
2425                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2426                                    .into_iter().map(|x| x.0).collect())
2427                            ;
2428                        }
2429                    }
2430                }
2431                Ok(ChangeLogNode {
2432                    need_op: need_op__.unwrap_or_default(),
2433                    distribution_keys: distribution_keys__.unwrap_or_default(),
2434                })
2435            }
2436        }
2437        deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2438    }
2439}
2440impl serde::Serialize for CombinedMutation {
2441    #[allow(deprecated)]
2442    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2443    where
2444        S: serde::Serializer,
2445    {
2446        use serde::ser::SerializeStruct;
2447        let mut len = 0;
2448        if !self.mutations.is_empty() {
2449            len += 1;
2450        }
2451        let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2452        if !self.mutations.is_empty() {
2453            struct_ser.serialize_field("mutations", &self.mutations)?;
2454        }
2455        struct_ser.end()
2456    }
2457}
2458impl<'de> serde::Deserialize<'de> for CombinedMutation {
2459    #[allow(deprecated)]
2460    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2461    where
2462        D: serde::Deserializer<'de>,
2463    {
2464        const FIELDS: &[&str] = &[
2465            "mutations",
2466        ];
2467
2468        #[allow(clippy::enum_variant_names)]
2469        enum GeneratedField {
2470            Mutations,
2471        }
2472        impl<'de> serde::Deserialize<'de> for GeneratedField {
2473            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2474            where
2475                D: serde::Deserializer<'de>,
2476            {
2477                struct GeneratedVisitor;
2478
2479                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2480                    type Value = GeneratedField;
2481
2482                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2483                        write!(formatter, "expected one of: {:?}", &FIELDS)
2484                    }
2485
2486                    #[allow(unused_variables)]
2487                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2488                    where
2489                        E: serde::de::Error,
2490                    {
2491                        match value {
2492                            "mutations" => Ok(GeneratedField::Mutations),
2493                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2494                        }
2495                    }
2496                }
2497                deserializer.deserialize_identifier(GeneratedVisitor)
2498            }
2499        }
2500        struct GeneratedVisitor;
2501        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2502            type Value = CombinedMutation;
2503
2504            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2505                formatter.write_str("struct stream_plan.CombinedMutation")
2506            }
2507
2508            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2509                where
2510                    V: serde::de::MapAccess<'de>,
2511            {
2512                let mut mutations__ = None;
2513                while let Some(k) = map_.next_key()? {
2514                    match k {
2515                        GeneratedField::Mutations => {
2516                            if mutations__.is_some() {
2517                                return Err(serde::de::Error::duplicate_field("mutations"));
2518                            }
2519                            mutations__ = Some(map_.next_value()?);
2520                        }
2521                    }
2522                }
2523                Ok(CombinedMutation {
2524                    mutations: mutations__.unwrap_or_default(),
2525                })
2526            }
2527        }
2528        deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2529    }
2530}
2531impl serde::Serialize for ConnectorPropsChangeMutation {
2532    #[allow(deprecated)]
2533    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2534    where
2535        S: serde::Serializer,
2536    {
2537        use serde::ser::SerializeStruct;
2538        let mut len = 0;
2539        if !self.connector_props_infos.is_empty() {
2540            len += 1;
2541        }
2542        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2543        if !self.connector_props_infos.is_empty() {
2544            struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2545        }
2546        struct_ser.end()
2547    }
2548}
2549impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2550    #[allow(deprecated)]
2551    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2552    where
2553        D: serde::Deserializer<'de>,
2554    {
2555        const FIELDS: &[&str] = &[
2556            "connector_props_infos",
2557            "connectorPropsInfos",
2558        ];
2559
2560        #[allow(clippy::enum_variant_names)]
2561        enum GeneratedField {
2562            ConnectorPropsInfos,
2563        }
2564        impl<'de> serde::Deserialize<'de> for GeneratedField {
2565            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2566            where
2567                D: serde::Deserializer<'de>,
2568            {
2569                struct GeneratedVisitor;
2570
2571                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2572                    type Value = GeneratedField;
2573
2574                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2575                        write!(formatter, "expected one of: {:?}", &FIELDS)
2576                    }
2577
2578                    #[allow(unused_variables)]
2579                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2580                    where
2581                        E: serde::de::Error,
2582                    {
2583                        match value {
2584                            "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2585                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2586                        }
2587                    }
2588                }
2589                deserializer.deserialize_identifier(GeneratedVisitor)
2590            }
2591        }
2592        struct GeneratedVisitor;
2593        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2594            type Value = ConnectorPropsChangeMutation;
2595
2596            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2598            }
2599
2600            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2601                where
2602                    V: serde::de::MapAccess<'de>,
2603            {
2604                let mut connector_props_infos__ = None;
2605                while let Some(k) = map_.next_key()? {
2606                    match k {
2607                        GeneratedField::ConnectorPropsInfos => {
2608                            if connector_props_infos__.is_some() {
2609                                return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2610                            }
2611                            connector_props_infos__ = Some(
2612                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2613                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2614                            );
2615                        }
2616                    }
2617                }
2618                Ok(ConnectorPropsChangeMutation {
2619                    connector_props_infos: connector_props_infos__.unwrap_or_default(),
2620                })
2621            }
2622        }
2623        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2624    }
2625}
2626impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2627    #[allow(deprecated)]
2628    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2629    where
2630        S: serde::Serializer,
2631    {
2632        use serde::ser::SerializeStruct;
2633        let mut len = 0;
2634        if !self.connector_props_info.is_empty() {
2635            len += 1;
2636        }
2637        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2638        if !self.connector_props_info.is_empty() {
2639            struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2640        }
2641        struct_ser.end()
2642    }
2643}
2644impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2645    #[allow(deprecated)]
2646    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2647    where
2648        D: serde::Deserializer<'de>,
2649    {
2650        const FIELDS: &[&str] = &[
2651            "connector_props_info",
2652            "connectorPropsInfo",
2653        ];
2654
2655        #[allow(clippy::enum_variant_names)]
2656        enum GeneratedField {
2657            ConnectorPropsInfo,
2658        }
2659        impl<'de> serde::Deserialize<'de> for GeneratedField {
2660            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2661            where
2662                D: serde::Deserializer<'de>,
2663            {
2664                struct GeneratedVisitor;
2665
2666                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2667                    type Value = GeneratedField;
2668
2669                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2670                        write!(formatter, "expected one of: {:?}", &FIELDS)
2671                    }
2672
2673                    #[allow(unused_variables)]
2674                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2675                    where
2676                        E: serde::de::Error,
2677                    {
2678                        match value {
2679                            "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2680                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2681                        }
2682                    }
2683                }
2684                deserializer.deserialize_identifier(GeneratedVisitor)
2685            }
2686        }
2687        struct GeneratedVisitor;
2688        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2689            type Value = connector_props_change_mutation::ConnectorPropsInfo;
2690
2691            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2692                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2693            }
2694
2695            fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2696                where
2697                    V: serde::de::MapAccess<'de>,
2698            {
2699                let mut connector_props_info__ = None;
2700                while let Some(k) = map_.next_key()? {
2701                    match k {
2702                        GeneratedField::ConnectorPropsInfo => {
2703                            if connector_props_info__.is_some() {
2704                                return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2705                            }
2706                            connector_props_info__ = Some(
2707                                map_.next_value::<std::collections::HashMap<_, _>>()?
2708                            );
2709                        }
2710                    }
2711                }
2712                Ok(connector_props_change_mutation::ConnectorPropsInfo {
2713                    connector_props_info: connector_props_info__.unwrap_or_default(),
2714                })
2715            }
2716        }
2717        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2718    }
2719}
2720impl serde::Serialize for DedupNode {
2721    #[allow(deprecated)]
2722    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2723    where
2724        S: serde::Serializer,
2725    {
2726        use serde::ser::SerializeStruct;
2727        let mut len = 0;
2728        if self.state_table.is_some() {
2729            len += 1;
2730        }
2731        if !self.dedup_column_indices.is_empty() {
2732            len += 1;
2733        }
2734        let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2735        if let Some(v) = self.state_table.as_ref() {
2736            struct_ser.serialize_field("stateTable", v)?;
2737        }
2738        if !self.dedup_column_indices.is_empty() {
2739            struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2740        }
2741        struct_ser.end()
2742    }
2743}
2744impl<'de> serde::Deserialize<'de> for DedupNode {
2745    #[allow(deprecated)]
2746    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2747    where
2748        D: serde::Deserializer<'de>,
2749    {
2750        const FIELDS: &[&str] = &[
2751            "state_table",
2752            "stateTable",
2753            "dedup_column_indices",
2754            "dedupColumnIndices",
2755        ];
2756
2757        #[allow(clippy::enum_variant_names)]
2758        enum GeneratedField {
2759            StateTable,
2760            DedupColumnIndices,
2761        }
2762        impl<'de> serde::Deserialize<'de> for GeneratedField {
2763            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2764            where
2765                D: serde::Deserializer<'de>,
2766            {
2767                struct GeneratedVisitor;
2768
2769                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2770                    type Value = GeneratedField;
2771
2772                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2773                        write!(formatter, "expected one of: {:?}", &FIELDS)
2774                    }
2775
2776                    #[allow(unused_variables)]
2777                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2778                    where
2779                        E: serde::de::Error,
2780                    {
2781                        match value {
2782                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2783                            "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2784                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2785                        }
2786                    }
2787                }
2788                deserializer.deserialize_identifier(GeneratedVisitor)
2789            }
2790        }
2791        struct GeneratedVisitor;
2792        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2793            type Value = DedupNode;
2794
2795            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2796                formatter.write_str("struct stream_plan.DedupNode")
2797            }
2798
2799            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2800                where
2801                    V: serde::de::MapAccess<'de>,
2802            {
2803                let mut state_table__ = None;
2804                let mut dedup_column_indices__ = None;
2805                while let Some(k) = map_.next_key()? {
2806                    match k {
2807                        GeneratedField::StateTable => {
2808                            if state_table__.is_some() {
2809                                return Err(serde::de::Error::duplicate_field("stateTable"));
2810                            }
2811                            state_table__ = map_.next_value()?;
2812                        }
2813                        GeneratedField::DedupColumnIndices => {
2814                            if dedup_column_indices__.is_some() {
2815                                return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2816                            }
2817                            dedup_column_indices__ = 
2818                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2819                                    .into_iter().map(|x| x.0).collect())
2820                            ;
2821                        }
2822                    }
2823                }
2824                Ok(DedupNode {
2825                    state_table: state_table__,
2826                    dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2827                })
2828            }
2829        }
2830        deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2831    }
2832}
2833impl serde::Serialize for DeltaExpression {
2834    #[allow(deprecated)]
2835    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2836    where
2837        S: serde::Serializer,
2838    {
2839        use serde::ser::SerializeStruct;
2840        let mut len = 0;
2841        if self.delta_type != 0 {
2842            len += 1;
2843        }
2844        if self.delta.is_some() {
2845            len += 1;
2846        }
2847        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2848        if self.delta_type != 0 {
2849            let v = super::expr::expr_node::Type::try_from(self.delta_type)
2850                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2851            struct_ser.serialize_field("deltaType", &v)?;
2852        }
2853        if let Some(v) = self.delta.as_ref() {
2854            struct_ser.serialize_field("delta", v)?;
2855        }
2856        struct_ser.end()
2857    }
2858}
2859impl<'de> serde::Deserialize<'de> for DeltaExpression {
2860    #[allow(deprecated)]
2861    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2862    where
2863        D: serde::Deserializer<'de>,
2864    {
2865        const FIELDS: &[&str] = &[
2866            "delta_type",
2867            "deltaType",
2868            "delta",
2869        ];
2870
2871        #[allow(clippy::enum_variant_names)]
2872        enum GeneratedField {
2873            DeltaType,
2874            Delta,
2875        }
2876        impl<'de> serde::Deserialize<'de> for GeneratedField {
2877            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2878            where
2879                D: serde::Deserializer<'de>,
2880            {
2881                struct GeneratedVisitor;
2882
2883                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2884                    type Value = GeneratedField;
2885
2886                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2887                        write!(formatter, "expected one of: {:?}", &FIELDS)
2888                    }
2889
2890                    #[allow(unused_variables)]
2891                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2892                    where
2893                        E: serde::de::Error,
2894                    {
2895                        match value {
2896                            "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2897                            "delta" => Ok(GeneratedField::Delta),
2898                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2899                        }
2900                    }
2901                }
2902                deserializer.deserialize_identifier(GeneratedVisitor)
2903            }
2904        }
2905        struct GeneratedVisitor;
2906        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2907            type Value = DeltaExpression;
2908
2909            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2910                formatter.write_str("struct stream_plan.DeltaExpression")
2911            }
2912
2913            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2914                where
2915                    V: serde::de::MapAccess<'de>,
2916            {
2917                let mut delta_type__ = None;
2918                let mut delta__ = None;
2919                while let Some(k) = map_.next_key()? {
2920                    match k {
2921                        GeneratedField::DeltaType => {
2922                            if delta_type__.is_some() {
2923                                return Err(serde::de::Error::duplicate_field("deltaType"));
2924                            }
2925                            delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2926                        }
2927                        GeneratedField::Delta => {
2928                            if delta__.is_some() {
2929                                return Err(serde::de::Error::duplicate_field("delta"));
2930                            }
2931                            delta__ = map_.next_value()?;
2932                        }
2933                    }
2934                }
2935                Ok(DeltaExpression {
2936                    delta_type: delta_type__.unwrap_or_default(),
2937                    delta: delta__,
2938                })
2939            }
2940        }
2941        deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2942    }
2943}
2944impl serde::Serialize for DeltaIndexJoinNode {
2945    #[allow(deprecated)]
2946    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2947    where
2948        S: serde::Serializer,
2949    {
2950        use serde::ser::SerializeStruct;
2951        let mut len = 0;
2952        if self.join_type != 0 {
2953            len += 1;
2954        }
2955        if !self.left_key.is_empty() {
2956            len += 1;
2957        }
2958        if !self.right_key.is_empty() {
2959            len += 1;
2960        }
2961        if self.condition.is_some() {
2962            len += 1;
2963        }
2964        if self.left_table_id != 0 {
2965            len += 1;
2966        }
2967        if self.right_table_id != 0 {
2968            len += 1;
2969        }
2970        if self.left_info.is_some() {
2971            len += 1;
2972        }
2973        if self.right_info.is_some() {
2974            len += 1;
2975        }
2976        if !self.output_indices.is_empty() {
2977            len += 1;
2978        }
2979        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2980        if self.join_type != 0 {
2981            let v = super::plan_common::JoinType::try_from(self.join_type)
2982                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2983            struct_ser.serialize_field("joinType", &v)?;
2984        }
2985        if !self.left_key.is_empty() {
2986            struct_ser.serialize_field("leftKey", &self.left_key)?;
2987        }
2988        if !self.right_key.is_empty() {
2989            struct_ser.serialize_field("rightKey", &self.right_key)?;
2990        }
2991        if let Some(v) = self.condition.as_ref() {
2992            struct_ser.serialize_field("condition", v)?;
2993        }
2994        if self.left_table_id != 0 {
2995            struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2996        }
2997        if self.right_table_id != 0 {
2998            struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2999        }
3000        if let Some(v) = self.left_info.as_ref() {
3001            struct_ser.serialize_field("leftInfo", v)?;
3002        }
3003        if let Some(v) = self.right_info.as_ref() {
3004            struct_ser.serialize_field("rightInfo", v)?;
3005        }
3006        if !self.output_indices.is_empty() {
3007            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3008        }
3009        struct_ser.end()
3010    }
3011}
3012impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3013    #[allow(deprecated)]
3014    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3015    where
3016        D: serde::Deserializer<'de>,
3017    {
3018        const FIELDS: &[&str] = &[
3019            "join_type",
3020            "joinType",
3021            "left_key",
3022            "leftKey",
3023            "right_key",
3024            "rightKey",
3025            "condition",
3026            "left_table_id",
3027            "leftTableId",
3028            "right_table_id",
3029            "rightTableId",
3030            "left_info",
3031            "leftInfo",
3032            "right_info",
3033            "rightInfo",
3034            "output_indices",
3035            "outputIndices",
3036        ];
3037
3038        #[allow(clippy::enum_variant_names)]
3039        enum GeneratedField {
3040            JoinType,
3041            LeftKey,
3042            RightKey,
3043            Condition,
3044            LeftTableId,
3045            RightTableId,
3046            LeftInfo,
3047            RightInfo,
3048            OutputIndices,
3049        }
3050        impl<'de> serde::Deserialize<'de> for GeneratedField {
3051            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3052            where
3053                D: serde::Deserializer<'de>,
3054            {
3055                struct GeneratedVisitor;
3056
3057                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3058                    type Value = GeneratedField;
3059
3060                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3061                        write!(formatter, "expected one of: {:?}", &FIELDS)
3062                    }
3063
3064                    #[allow(unused_variables)]
3065                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3066                    where
3067                        E: serde::de::Error,
3068                    {
3069                        match value {
3070                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3071                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3072                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3073                            "condition" => Ok(GeneratedField::Condition),
3074                            "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3075                            "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3076                            "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3077                            "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3078                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3079                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3080                        }
3081                    }
3082                }
3083                deserializer.deserialize_identifier(GeneratedVisitor)
3084            }
3085        }
3086        struct GeneratedVisitor;
3087        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3088            type Value = DeltaIndexJoinNode;
3089
3090            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3091                formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3092            }
3093
3094            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3095                where
3096                    V: serde::de::MapAccess<'de>,
3097            {
3098                let mut join_type__ = None;
3099                let mut left_key__ = None;
3100                let mut right_key__ = None;
3101                let mut condition__ = None;
3102                let mut left_table_id__ = None;
3103                let mut right_table_id__ = None;
3104                let mut left_info__ = None;
3105                let mut right_info__ = None;
3106                let mut output_indices__ = None;
3107                while let Some(k) = map_.next_key()? {
3108                    match k {
3109                        GeneratedField::JoinType => {
3110                            if join_type__.is_some() {
3111                                return Err(serde::de::Error::duplicate_field("joinType"));
3112                            }
3113                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3114                        }
3115                        GeneratedField::LeftKey => {
3116                            if left_key__.is_some() {
3117                                return Err(serde::de::Error::duplicate_field("leftKey"));
3118                            }
3119                            left_key__ = 
3120                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3121                                    .into_iter().map(|x| x.0).collect())
3122                            ;
3123                        }
3124                        GeneratedField::RightKey => {
3125                            if right_key__.is_some() {
3126                                return Err(serde::de::Error::duplicate_field("rightKey"));
3127                            }
3128                            right_key__ = 
3129                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3130                                    .into_iter().map(|x| x.0).collect())
3131                            ;
3132                        }
3133                        GeneratedField::Condition => {
3134                            if condition__.is_some() {
3135                                return Err(serde::de::Error::duplicate_field("condition"));
3136                            }
3137                            condition__ = map_.next_value()?;
3138                        }
3139                        GeneratedField::LeftTableId => {
3140                            if left_table_id__.is_some() {
3141                                return Err(serde::de::Error::duplicate_field("leftTableId"));
3142                            }
3143                            left_table_id__ = 
3144                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3145                            ;
3146                        }
3147                        GeneratedField::RightTableId => {
3148                            if right_table_id__.is_some() {
3149                                return Err(serde::de::Error::duplicate_field("rightTableId"));
3150                            }
3151                            right_table_id__ = 
3152                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3153                            ;
3154                        }
3155                        GeneratedField::LeftInfo => {
3156                            if left_info__.is_some() {
3157                                return Err(serde::de::Error::duplicate_field("leftInfo"));
3158                            }
3159                            left_info__ = map_.next_value()?;
3160                        }
3161                        GeneratedField::RightInfo => {
3162                            if right_info__.is_some() {
3163                                return Err(serde::de::Error::duplicate_field("rightInfo"));
3164                            }
3165                            right_info__ = map_.next_value()?;
3166                        }
3167                        GeneratedField::OutputIndices => {
3168                            if output_indices__.is_some() {
3169                                return Err(serde::de::Error::duplicate_field("outputIndices"));
3170                            }
3171                            output_indices__ = 
3172                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3173                                    .into_iter().map(|x| x.0).collect())
3174                            ;
3175                        }
3176                    }
3177                }
3178                Ok(DeltaIndexJoinNode {
3179                    join_type: join_type__.unwrap_or_default(),
3180                    left_key: left_key__.unwrap_or_default(),
3181                    right_key: right_key__.unwrap_or_default(),
3182                    condition: condition__,
3183                    left_table_id: left_table_id__.unwrap_or_default(),
3184                    right_table_id: right_table_id__.unwrap_or_default(),
3185                    left_info: left_info__,
3186                    right_info: right_info__,
3187                    output_indices: output_indices__.unwrap_or_default(),
3188                })
3189            }
3190        }
3191        deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3192    }
3193}
3194impl serde::Serialize for DispatchOutputMapping {
3195    #[allow(deprecated)]
3196    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3197    where
3198        S: serde::Serializer,
3199    {
3200        use serde::ser::SerializeStruct;
3201        let mut len = 0;
3202        if !self.indices.is_empty() {
3203            len += 1;
3204        }
3205        if !self.types.is_empty() {
3206            len += 1;
3207        }
3208        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3209        if !self.indices.is_empty() {
3210            struct_ser.serialize_field("indices", &self.indices)?;
3211        }
3212        if !self.types.is_empty() {
3213            struct_ser.serialize_field("types", &self.types)?;
3214        }
3215        struct_ser.end()
3216    }
3217}
3218impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3219    #[allow(deprecated)]
3220    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3221    where
3222        D: serde::Deserializer<'de>,
3223    {
3224        const FIELDS: &[&str] = &[
3225            "indices",
3226            "types",
3227        ];
3228
3229        #[allow(clippy::enum_variant_names)]
3230        enum GeneratedField {
3231            Indices,
3232            Types,
3233        }
3234        impl<'de> serde::Deserialize<'de> for GeneratedField {
3235            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3236            where
3237                D: serde::Deserializer<'de>,
3238            {
3239                struct GeneratedVisitor;
3240
3241                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3242                    type Value = GeneratedField;
3243
3244                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3245                        write!(formatter, "expected one of: {:?}", &FIELDS)
3246                    }
3247
3248                    #[allow(unused_variables)]
3249                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3250                    where
3251                        E: serde::de::Error,
3252                    {
3253                        match value {
3254                            "indices" => Ok(GeneratedField::Indices),
3255                            "types" => Ok(GeneratedField::Types),
3256                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3257                        }
3258                    }
3259                }
3260                deserializer.deserialize_identifier(GeneratedVisitor)
3261            }
3262        }
3263        struct GeneratedVisitor;
3264        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3265            type Value = DispatchOutputMapping;
3266
3267            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3268                formatter.write_str("struct stream_plan.DispatchOutputMapping")
3269            }
3270
3271            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3272                where
3273                    V: serde::de::MapAccess<'de>,
3274            {
3275                let mut indices__ = None;
3276                let mut types__ = None;
3277                while let Some(k) = map_.next_key()? {
3278                    match k {
3279                        GeneratedField::Indices => {
3280                            if indices__.is_some() {
3281                                return Err(serde::de::Error::duplicate_field("indices"));
3282                            }
3283                            indices__ = 
3284                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3285                                    .into_iter().map(|x| x.0).collect())
3286                            ;
3287                        }
3288                        GeneratedField::Types => {
3289                            if types__.is_some() {
3290                                return Err(serde::de::Error::duplicate_field("types"));
3291                            }
3292                            types__ = Some(map_.next_value()?);
3293                        }
3294                    }
3295                }
3296                Ok(DispatchOutputMapping {
3297                    indices: indices__.unwrap_or_default(),
3298                    types: types__.unwrap_or_default(),
3299                })
3300            }
3301        }
3302        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3303    }
3304}
3305impl serde::Serialize for dispatch_output_mapping::TypePair {
3306    #[allow(deprecated)]
3307    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3308    where
3309        S: serde::Serializer,
3310    {
3311        use serde::ser::SerializeStruct;
3312        let mut len = 0;
3313        if self.upstream.is_some() {
3314            len += 1;
3315        }
3316        if self.downstream.is_some() {
3317            len += 1;
3318        }
3319        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3320        if let Some(v) = self.upstream.as_ref() {
3321            struct_ser.serialize_field("upstream", v)?;
3322        }
3323        if let Some(v) = self.downstream.as_ref() {
3324            struct_ser.serialize_field("downstream", v)?;
3325        }
3326        struct_ser.end()
3327    }
3328}
3329impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3330    #[allow(deprecated)]
3331    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3332    where
3333        D: serde::Deserializer<'de>,
3334    {
3335        const FIELDS: &[&str] = &[
3336            "upstream",
3337            "downstream",
3338        ];
3339
3340        #[allow(clippy::enum_variant_names)]
3341        enum GeneratedField {
3342            Upstream,
3343            Downstream,
3344        }
3345        impl<'de> serde::Deserialize<'de> for GeneratedField {
3346            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3347            where
3348                D: serde::Deserializer<'de>,
3349            {
3350                struct GeneratedVisitor;
3351
3352                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3353                    type Value = GeneratedField;
3354
3355                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3356                        write!(formatter, "expected one of: {:?}", &FIELDS)
3357                    }
3358
3359                    #[allow(unused_variables)]
3360                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3361                    where
3362                        E: serde::de::Error,
3363                    {
3364                        match value {
3365                            "upstream" => Ok(GeneratedField::Upstream),
3366                            "downstream" => Ok(GeneratedField::Downstream),
3367                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3368                        }
3369                    }
3370                }
3371                deserializer.deserialize_identifier(GeneratedVisitor)
3372            }
3373        }
3374        struct GeneratedVisitor;
3375        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3376            type Value = dispatch_output_mapping::TypePair;
3377
3378            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3379                formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3380            }
3381
3382            fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3383                where
3384                    V: serde::de::MapAccess<'de>,
3385            {
3386                let mut upstream__ = None;
3387                let mut downstream__ = None;
3388                while let Some(k) = map_.next_key()? {
3389                    match k {
3390                        GeneratedField::Upstream => {
3391                            if upstream__.is_some() {
3392                                return Err(serde::de::Error::duplicate_field("upstream"));
3393                            }
3394                            upstream__ = map_.next_value()?;
3395                        }
3396                        GeneratedField::Downstream => {
3397                            if downstream__.is_some() {
3398                                return Err(serde::de::Error::duplicate_field("downstream"));
3399                            }
3400                            downstream__ = map_.next_value()?;
3401                        }
3402                    }
3403                }
3404                Ok(dispatch_output_mapping::TypePair {
3405                    upstream: upstream__,
3406                    downstream: downstream__,
3407                })
3408            }
3409        }
3410        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3411    }
3412}
3413impl serde::Serialize for DispatchStrategy {
3414    #[allow(deprecated)]
3415    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3416    where
3417        S: serde::Serializer,
3418    {
3419        use serde::ser::SerializeStruct;
3420        let mut len = 0;
3421        if self.r#type != 0 {
3422            len += 1;
3423        }
3424        if !self.dist_key_indices.is_empty() {
3425            len += 1;
3426        }
3427        if self.output_mapping.is_some() {
3428            len += 1;
3429        }
3430        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3431        if self.r#type != 0 {
3432            let v = DispatcherType::try_from(self.r#type)
3433                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3434            struct_ser.serialize_field("type", &v)?;
3435        }
3436        if !self.dist_key_indices.is_empty() {
3437            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3438        }
3439        if let Some(v) = self.output_mapping.as_ref() {
3440            struct_ser.serialize_field("outputMapping", v)?;
3441        }
3442        struct_ser.end()
3443    }
3444}
3445impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3446    #[allow(deprecated)]
3447    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3448    where
3449        D: serde::Deserializer<'de>,
3450    {
3451        const FIELDS: &[&str] = &[
3452            "type",
3453            "dist_key_indices",
3454            "distKeyIndices",
3455            "output_mapping",
3456            "outputMapping",
3457        ];
3458
3459        #[allow(clippy::enum_variant_names)]
3460        enum GeneratedField {
3461            Type,
3462            DistKeyIndices,
3463            OutputMapping,
3464        }
3465        impl<'de> serde::Deserialize<'de> for GeneratedField {
3466            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3467            where
3468                D: serde::Deserializer<'de>,
3469            {
3470                struct GeneratedVisitor;
3471
3472                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3473                    type Value = GeneratedField;
3474
3475                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3476                        write!(formatter, "expected one of: {:?}", &FIELDS)
3477                    }
3478
3479                    #[allow(unused_variables)]
3480                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3481                    where
3482                        E: serde::de::Error,
3483                    {
3484                        match value {
3485                            "type" => Ok(GeneratedField::Type),
3486                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3487                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3488                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3489                        }
3490                    }
3491                }
3492                deserializer.deserialize_identifier(GeneratedVisitor)
3493            }
3494        }
3495        struct GeneratedVisitor;
3496        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3497            type Value = DispatchStrategy;
3498
3499            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3500                formatter.write_str("struct stream_plan.DispatchStrategy")
3501            }
3502
3503            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3504                where
3505                    V: serde::de::MapAccess<'de>,
3506            {
3507                let mut r#type__ = None;
3508                let mut dist_key_indices__ = None;
3509                let mut output_mapping__ = None;
3510                while let Some(k) = map_.next_key()? {
3511                    match k {
3512                        GeneratedField::Type => {
3513                            if r#type__.is_some() {
3514                                return Err(serde::de::Error::duplicate_field("type"));
3515                            }
3516                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3517                        }
3518                        GeneratedField::DistKeyIndices => {
3519                            if dist_key_indices__.is_some() {
3520                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3521                            }
3522                            dist_key_indices__ = 
3523                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3524                                    .into_iter().map(|x| x.0).collect())
3525                            ;
3526                        }
3527                        GeneratedField::OutputMapping => {
3528                            if output_mapping__.is_some() {
3529                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3530                            }
3531                            output_mapping__ = map_.next_value()?;
3532                        }
3533                    }
3534                }
3535                Ok(DispatchStrategy {
3536                    r#type: r#type__.unwrap_or_default(),
3537                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3538                    output_mapping: output_mapping__,
3539                })
3540            }
3541        }
3542        deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3543    }
3544}
3545impl serde::Serialize for Dispatcher {
3546    #[allow(deprecated)]
3547    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3548    where
3549        S: serde::Serializer,
3550    {
3551        use serde::ser::SerializeStruct;
3552        let mut len = 0;
3553        if self.r#type != 0 {
3554            len += 1;
3555        }
3556        if !self.dist_key_indices.is_empty() {
3557            len += 1;
3558        }
3559        if self.output_mapping.is_some() {
3560            len += 1;
3561        }
3562        if self.hash_mapping.is_some() {
3563            len += 1;
3564        }
3565        if self.dispatcher_id != 0 {
3566            len += 1;
3567        }
3568        if !self.downstream_actor_id.is_empty() {
3569            len += 1;
3570        }
3571        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3572        if self.r#type != 0 {
3573            let v = DispatcherType::try_from(self.r#type)
3574                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3575            struct_ser.serialize_field("type", &v)?;
3576        }
3577        if !self.dist_key_indices.is_empty() {
3578            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3579        }
3580        if let Some(v) = self.output_mapping.as_ref() {
3581            struct_ser.serialize_field("outputMapping", v)?;
3582        }
3583        if let Some(v) = self.hash_mapping.as_ref() {
3584            struct_ser.serialize_field("hashMapping", v)?;
3585        }
3586        if self.dispatcher_id != 0 {
3587            #[allow(clippy::needless_borrow)]
3588            #[allow(clippy::needless_borrows_for_generic_args)]
3589            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3590        }
3591        if !self.downstream_actor_id.is_empty() {
3592            struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3593        }
3594        struct_ser.end()
3595    }
3596}
3597impl<'de> serde::Deserialize<'de> for Dispatcher {
3598    #[allow(deprecated)]
3599    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3600    where
3601        D: serde::Deserializer<'de>,
3602    {
3603        const FIELDS: &[&str] = &[
3604            "type",
3605            "dist_key_indices",
3606            "distKeyIndices",
3607            "output_mapping",
3608            "outputMapping",
3609            "hash_mapping",
3610            "hashMapping",
3611            "dispatcher_id",
3612            "dispatcherId",
3613            "downstream_actor_id",
3614            "downstreamActorId",
3615        ];
3616
3617        #[allow(clippy::enum_variant_names)]
3618        enum GeneratedField {
3619            Type,
3620            DistKeyIndices,
3621            OutputMapping,
3622            HashMapping,
3623            DispatcherId,
3624            DownstreamActorId,
3625        }
3626        impl<'de> serde::Deserialize<'de> for GeneratedField {
3627            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3628            where
3629                D: serde::Deserializer<'de>,
3630            {
3631                struct GeneratedVisitor;
3632
3633                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3634                    type Value = GeneratedField;
3635
3636                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3637                        write!(formatter, "expected one of: {:?}", &FIELDS)
3638                    }
3639
3640                    #[allow(unused_variables)]
3641                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3642                    where
3643                        E: serde::de::Error,
3644                    {
3645                        match value {
3646                            "type" => Ok(GeneratedField::Type),
3647                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3648                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3649                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3650                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3651                            "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3652                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3653                        }
3654                    }
3655                }
3656                deserializer.deserialize_identifier(GeneratedVisitor)
3657            }
3658        }
3659        struct GeneratedVisitor;
3660        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3661            type Value = Dispatcher;
3662
3663            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3664                formatter.write_str("struct stream_plan.Dispatcher")
3665            }
3666
3667            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3668                where
3669                    V: serde::de::MapAccess<'de>,
3670            {
3671                let mut r#type__ = None;
3672                let mut dist_key_indices__ = None;
3673                let mut output_mapping__ = None;
3674                let mut hash_mapping__ = None;
3675                let mut dispatcher_id__ = None;
3676                let mut downstream_actor_id__ = None;
3677                while let Some(k) = map_.next_key()? {
3678                    match k {
3679                        GeneratedField::Type => {
3680                            if r#type__.is_some() {
3681                                return Err(serde::de::Error::duplicate_field("type"));
3682                            }
3683                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3684                        }
3685                        GeneratedField::DistKeyIndices => {
3686                            if dist_key_indices__.is_some() {
3687                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3688                            }
3689                            dist_key_indices__ = 
3690                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3691                                    .into_iter().map(|x| x.0).collect())
3692                            ;
3693                        }
3694                        GeneratedField::OutputMapping => {
3695                            if output_mapping__.is_some() {
3696                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3697                            }
3698                            output_mapping__ = map_.next_value()?;
3699                        }
3700                        GeneratedField::HashMapping => {
3701                            if hash_mapping__.is_some() {
3702                                return Err(serde::de::Error::duplicate_field("hashMapping"));
3703                            }
3704                            hash_mapping__ = map_.next_value()?;
3705                        }
3706                        GeneratedField::DispatcherId => {
3707                            if dispatcher_id__.is_some() {
3708                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
3709                            }
3710                            dispatcher_id__ = 
3711                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3712                            ;
3713                        }
3714                        GeneratedField::DownstreamActorId => {
3715                            if downstream_actor_id__.is_some() {
3716                                return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3717                            }
3718                            downstream_actor_id__ = 
3719                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3720                                    .into_iter().map(|x| x.0).collect())
3721                            ;
3722                        }
3723                    }
3724                }
3725                Ok(Dispatcher {
3726                    r#type: r#type__.unwrap_or_default(),
3727                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3728                    output_mapping: output_mapping__,
3729                    hash_mapping: hash_mapping__,
3730                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
3731                    downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3732                })
3733            }
3734        }
3735        deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3736    }
3737}
3738impl serde::Serialize for DispatcherType {
3739    #[allow(deprecated)]
3740    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3741    where
3742        S: serde::Serializer,
3743    {
3744        let variant = match self {
3745            Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3746            Self::Hash => "DISPATCHER_TYPE_HASH",
3747            Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3748            Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3749            Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3750        };
3751        serializer.serialize_str(variant)
3752    }
3753}
3754impl<'de> serde::Deserialize<'de> for DispatcherType {
3755    #[allow(deprecated)]
3756    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3757    where
3758        D: serde::Deserializer<'de>,
3759    {
3760        const FIELDS: &[&str] = &[
3761            "DISPATCHER_TYPE_UNSPECIFIED",
3762            "DISPATCHER_TYPE_HASH",
3763            "DISPATCHER_TYPE_BROADCAST",
3764            "DISPATCHER_TYPE_SIMPLE",
3765            "DISPATCHER_TYPE_NO_SHUFFLE",
3766        ];
3767
3768        struct GeneratedVisitor;
3769
3770        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3771            type Value = DispatcherType;
3772
3773            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3774                write!(formatter, "expected one of: {:?}", &FIELDS)
3775            }
3776
3777            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3778            where
3779                E: serde::de::Error,
3780            {
3781                i32::try_from(v)
3782                    .ok()
3783                    .and_then(|x| x.try_into().ok())
3784                    .ok_or_else(|| {
3785                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3786                    })
3787            }
3788
3789            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3790            where
3791                E: serde::de::Error,
3792            {
3793                i32::try_from(v)
3794                    .ok()
3795                    .and_then(|x| x.try_into().ok())
3796                    .ok_or_else(|| {
3797                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3798                    })
3799            }
3800
3801            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3802            where
3803                E: serde::de::Error,
3804            {
3805                match value {
3806                    "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3807                    "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3808                    "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3809                    "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3810                    "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3811                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3812                }
3813            }
3814        }
3815        deserializer.deserialize_any(GeneratedVisitor)
3816    }
3817}
3818impl serde::Serialize for Dispatchers {
3819    #[allow(deprecated)]
3820    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3821    where
3822        S: serde::Serializer,
3823    {
3824        use serde::ser::SerializeStruct;
3825        let mut len = 0;
3826        if !self.dispatchers.is_empty() {
3827            len += 1;
3828        }
3829        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3830        if !self.dispatchers.is_empty() {
3831            struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3832        }
3833        struct_ser.end()
3834    }
3835}
3836impl<'de> serde::Deserialize<'de> for Dispatchers {
3837    #[allow(deprecated)]
3838    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3839    where
3840        D: serde::Deserializer<'de>,
3841    {
3842        const FIELDS: &[&str] = &[
3843            "dispatchers",
3844        ];
3845
3846        #[allow(clippy::enum_variant_names)]
3847        enum GeneratedField {
3848            Dispatchers,
3849        }
3850        impl<'de> serde::Deserialize<'de> for GeneratedField {
3851            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3852            where
3853                D: serde::Deserializer<'de>,
3854            {
3855                struct GeneratedVisitor;
3856
3857                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3858                    type Value = GeneratedField;
3859
3860                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3861                        write!(formatter, "expected one of: {:?}", &FIELDS)
3862                    }
3863
3864                    #[allow(unused_variables)]
3865                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3866                    where
3867                        E: serde::de::Error,
3868                    {
3869                        match value {
3870                            "dispatchers" => Ok(GeneratedField::Dispatchers),
3871                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3872                        }
3873                    }
3874                }
3875                deserializer.deserialize_identifier(GeneratedVisitor)
3876            }
3877        }
3878        struct GeneratedVisitor;
3879        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3880            type Value = Dispatchers;
3881
3882            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3883                formatter.write_str("struct stream_plan.Dispatchers")
3884            }
3885
3886            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3887                where
3888                    V: serde::de::MapAccess<'de>,
3889            {
3890                let mut dispatchers__ = None;
3891                while let Some(k) = map_.next_key()? {
3892                    match k {
3893                        GeneratedField::Dispatchers => {
3894                            if dispatchers__.is_some() {
3895                                return Err(serde::de::Error::duplicate_field("dispatchers"));
3896                            }
3897                            dispatchers__ = Some(map_.next_value()?);
3898                        }
3899                    }
3900                }
3901                Ok(Dispatchers {
3902                    dispatchers: dispatchers__.unwrap_or_default(),
3903                })
3904            }
3905        }
3906        deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3907    }
3908}
3909impl serde::Serialize for DmlNode {
3910    #[allow(deprecated)]
3911    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3912    where
3913        S: serde::Serializer,
3914    {
3915        use serde::ser::SerializeStruct;
3916        let mut len = 0;
3917        if self.table_id != 0 {
3918            len += 1;
3919        }
3920        if self.table_version_id != 0 {
3921            len += 1;
3922        }
3923        if !self.column_descs.is_empty() {
3924            len += 1;
3925        }
3926        if self.rate_limit.is_some() {
3927            len += 1;
3928        }
3929        let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3930        if self.table_id != 0 {
3931            struct_ser.serialize_field("tableId", &self.table_id)?;
3932        }
3933        if self.table_version_id != 0 {
3934            #[allow(clippy::needless_borrow)]
3935            #[allow(clippy::needless_borrows_for_generic_args)]
3936            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3937        }
3938        if !self.column_descs.is_empty() {
3939            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3940        }
3941        if let Some(v) = self.rate_limit.as_ref() {
3942            struct_ser.serialize_field("rateLimit", v)?;
3943        }
3944        struct_ser.end()
3945    }
3946}
3947impl<'de> serde::Deserialize<'de> for DmlNode {
3948    #[allow(deprecated)]
3949    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3950    where
3951        D: serde::Deserializer<'de>,
3952    {
3953        const FIELDS: &[&str] = &[
3954            "table_id",
3955            "tableId",
3956            "table_version_id",
3957            "tableVersionId",
3958            "column_descs",
3959            "columnDescs",
3960            "rate_limit",
3961            "rateLimit",
3962        ];
3963
3964        #[allow(clippy::enum_variant_names)]
3965        enum GeneratedField {
3966            TableId,
3967            TableVersionId,
3968            ColumnDescs,
3969            RateLimit,
3970        }
3971        impl<'de> serde::Deserialize<'de> for GeneratedField {
3972            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3973            where
3974                D: serde::Deserializer<'de>,
3975            {
3976                struct GeneratedVisitor;
3977
3978                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3979                    type Value = GeneratedField;
3980
3981                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3982                        write!(formatter, "expected one of: {:?}", &FIELDS)
3983                    }
3984
3985                    #[allow(unused_variables)]
3986                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3987                    where
3988                        E: serde::de::Error,
3989                    {
3990                        match value {
3991                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
3992                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3993                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3994                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3995                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3996                        }
3997                    }
3998                }
3999                deserializer.deserialize_identifier(GeneratedVisitor)
4000            }
4001        }
4002        struct GeneratedVisitor;
4003        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4004            type Value = DmlNode;
4005
4006            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4007                formatter.write_str("struct stream_plan.DmlNode")
4008            }
4009
4010            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4011                where
4012                    V: serde::de::MapAccess<'de>,
4013            {
4014                let mut table_id__ = None;
4015                let mut table_version_id__ = None;
4016                let mut column_descs__ = None;
4017                let mut rate_limit__ = None;
4018                while let Some(k) = map_.next_key()? {
4019                    match k {
4020                        GeneratedField::TableId => {
4021                            if table_id__.is_some() {
4022                                return Err(serde::de::Error::duplicate_field("tableId"));
4023                            }
4024                            table_id__ = 
4025                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4026                            ;
4027                        }
4028                        GeneratedField::TableVersionId => {
4029                            if table_version_id__.is_some() {
4030                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
4031                            }
4032                            table_version_id__ = 
4033                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4034                            ;
4035                        }
4036                        GeneratedField::ColumnDescs => {
4037                            if column_descs__.is_some() {
4038                                return Err(serde::de::Error::duplicate_field("columnDescs"));
4039                            }
4040                            column_descs__ = Some(map_.next_value()?);
4041                        }
4042                        GeneratedField::RateLimit => {
4043                            if rate_limit__.is_some() {
4044                                return Err(serde::de::Error::duplicate_field("rateLimit"));
4045                            }
4046                            rate_limit__ = 
4047                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4048                            ;
4049                        }
4050                    }
4051                }
4052                Ok(DmlNode {
4053                    table_id: table_id__.unwrap_or_default(),
4054                    table_version_id: table_version_id__.unwrap_or_default(),
4055                    column_descs: column_descs__.unwrap_or_default(),
4056                    rate_limit: rate_limit__,
4057                })
4058            }
4059        }
4060        deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4061    }
4062}
4063impl serde::Serialize for DropSubscriptionsMutation {
4064    #[allow(deprecated)]
4065    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4066    where
4067        S: serde::Serializer,
4068    {
4069        use serde::ser::SerializeStruct;
4070        let mut len = 0;
4071        if !self.info.is_empty() {
4072            len += 1;
4073        }
4074        let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4075        if !self.info.is_empty() {
4076            struct_ser.serialize_field("info", &self.info)?;
4077        }
4078        struct_ser.end()
4079    }
4080}
4081impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4082    #[allow(deprecated)]
4083    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4084    where
4085        D: serde::Deserializer<'de>,
4086    {
4087        const FIELDS: &[&str] = &[
4088            "info",
4089        ];
4090
4091        #[allow(clippy::enum_variant_names)]
4092        enum GeneratedField {
4093            Info,
4094        }
4095        impl<'de> serde::Deserialize<'de> for GeneratedField {
4096            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4097            where
4098                D: serde::Deserializer<'de>,
4099            {
4100                struct GeneratedVisitor;
4101
4102                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4103                    type Value = GeneratedField;
4104
4105                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106                        write!(formatter, "expected one of: {:?}", &FIELDS)
4107                    }
4108
4109                    #[allow(unused_variables)]
4110                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4111                    where
4112                        E: serde::de::Error,
4113                    {
4114                        match value {
4115                            "info" => Ok(GeneratedField::Info),
4116                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4117                        }
4118                    }
4119                }
4120                deserializer.deserialize_identifier(GeneratedVisitor)
4121            }
4122        }
4123        struct GeneratedVisitor;
4124        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4125            type Value = DropSubscriptionsMutation;
4126
4127            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4128                formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4129            }
4130
4131            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4132                where
4133                    V: serde::de::MapAccess<'de>,
4134            {
4135                let mut info__ = None;
4136                while let Some(k) = map_.next_key()? {
4137                    match k {
4138                        GeneratedField::Info => {
4139                            if info__.is_some() {
4140                                return Err(serde::de::Error::duplicate_field("info"));
4141                            }
4142                            info__ = Some(map_.next_value()?);
4143                        }
4144                    }
4145                }
4146                Ok(DropSubscriptionsMutation {
4147                    info: info__.unwrap_or_default(),
4148                })
4149            }
4150        }
4151        deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4152    }
4153}
4154impl serde::Serialize for DynamicFilterNode {
4155    #[allow(deprecated)]
4156    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4157    where
4158        S: serde::Serializer,
4159    {
4160        use serde::ser::SerializeStruct;
4161        let mut len = 0;
4162        if self.left_key != 0 {
4163            len += 1;
4164        }
4165        if self.condition.is_some() {
4166            len += 1;
4167        }
4168        if self.left_table.is_some() {
4169            len += 1;
4170        }
4171        if self.right_table.is_some() {
4172            len += 1;
4173        }
4174        if self.condition_always_relax {
4175            len += 1;
4176        }
4177        let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4178        if self.left_key != 0 {
4179            struct_ser.serialize_field("leftKey", &self.left_key)?;
4180        }
4181        if let Some(v) = self.condition.as_ref() {
4182            struct_ser.serialize_field("condition", v)?;
4183        }
4184        if let Some(v) = self.left_table.as_ref() {
4185            struct_ser.serialize_field("leftTable", v)?;
4186        }
4187        if let Some(v) = self.right_table.as_ref() {
4188            struct_ser.serialize_field("rightTable", v)?;
4189        }
4190        if self.condition_always_relax {
4191            struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4192        }
4193        struct_ser.end()
4194    }
4195}
4196impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4197    #[allow(deprecated)]
4198    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4199    where
4200        D: serde::Deserializer<'de>,
4201    {
4202        const FIELDS: &[&str] = &[
4203            "left_key",
4204            "leftKey",
4205            "condition",
4206            "left_table",
4207            "leftTable",
4208            "right_table",
4209            "rightTable",
4210            "condition_always_relax",
4211            "conditionAlwaysRelax",
4212        ];
4213
4214        #[allow(clippy::enum_variant_names)]
4215        enum GeneratedField {
4216            LeftKey,
4217            Condition,
4218            LeftTable,
4219            RightTable,
4220            ConditionAlwaysRelax,
4221        }
4222        impl<'de> serde::Deserialize<'de> for GeneratedField {
4223            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4224            where
4225                D: serde::Deserializer<'de>,
4226            {
4227                struct GeneratedVisitor;
4228
4229                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4230                    type Value = GeneratedField;
4231
4232                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4233                        write!(formatter, "expected one of: {:?}", &FIELDS)
4234                    }
4235
4236                    #[allow(unused_variables)]
4237                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4238                    where
4239                        E: serde::de::Error,
4240                    {
4241                        match value {
4242                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4243                            "condition" => Ok(GeneratedField::Condition),
4244                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4245                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4246                            "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4247                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4248                        }
4249                    }
4250                }
4251                deserializer.deserialize_identifier(GeneratedVisitor)
4252            }
4253        }
4254        struct GeneratedVisitor;
4255        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4256            type Value = DynamicFilterNode;
4257
4258            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4259                formatter.write_str("struct stream_plan.DynamicFilterNode")
4260            }
4261
4262            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4263                where
4264                    V: serde::de::MapAccess<'de>,
4265            {
4266                let mut left_key__ = None;
4267                let mut condition__ = None;
4268                let mut left_table__ = None;
4269                let mut right_table__ = None;
4270                let mut condition_always_relax__ = None;
4271                while let Some(k) = map_.next_key()? {
4272                    match k {
4273                        GeneratedField::LeftKey => {
4274                            if left_key__.is_some() {
4275                                return Err(serde::de::Error::duplicate_field("leftKey"));
4276                            }
4277                            left_key__ = 
4278                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4279                            ;
4280                        }
4281                        GeneratedField::Condition => {
4282                            if condition__.is_some() {
4283                                return Err(serde::de::Error::duplicate_field("condition"));
4284                            }
4285                            condition__ = map_.next_value()?;
4286                        }
4287                        GeneratedField::LeftTable => {
4288                            if left_table__.is_some() {
4289                                return Err(serde::de::Error::duplicate_field("leftTable"));
4290                            }
4291                            left_table__ = map_.next_value()?;
4292                        }
4293                        GeneratedField::RightTable => {
4294                            if right_table__.is_some() {
4295                                return Err(serde::de::Error::duplicate_field("rightTable"));
4296                            }
4297                            right_table__ = map_.next_value()?;
4298                        }
4299                        GeneratedField::ConditionAlwaysRelax => {
4300                            if condition_always_relax__.is_some() {
4301                                return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4302                            }
4303                            condition_always_relax__ = Some(map_.next_value()?);
4304                        }
4305                    }
4306                }
4307                Ok(DynamicFilterNode {
4308                    left_key: left_key__.unwrap_or_default(),
4309                    condition: condition__,
4310                    left_table: left_table__,
4311                    right_table: right_table__,
4312                    condition_always_relax: condition_always_relax__.unwrap_or_default(),
4313                })
4314            }
4315        }
4316        deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4317    }
4318}
4319impl serde::Serialize for EowcOverWindowNode {
4320    #[allow(deprecated)]
4321    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4322    where
4323        S: serde::Serializer,
4324    {
4325        use serde::ser::SerializeStruct;
4326        let mut len = 0;
4327        if !self.calls.is_empty() {
4328            len += 1;
4329        }
4330        if !self.partition_by.is_empty() {
4331            len += 1;
4332        }
4333        if !self.order_by.is_empty() {
4334            len += 1;
4335        }
4336        if self.state_table.is_some() {
4337            len += 1;
4338        }
4339        let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4340        if !self.calls.is_empty() {
4341            struct_ser.serialize_field("calls", &self.calls)?;
4342        }
4343        if !self.partition_by.is_empty() {
4344            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4345        }
4346        if !self.order_by.is_empty() {
4347            struct_ser.serialize_field("orderBy", &self.order_by)?;
4348        }
4349        if let Some(v) = self.state_table.as_ref() {
4350            struct_ser.serialize_field("stateTable", v)?;
4351        }
4352        struct_ser.end()
4353    }
4354}
4355impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4356    #[allow(deprecated)]
4357    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4358    where
4359        D: serde::Deserializer<'de>,
4360    {
4361        const FIELDS: &[&str] = &[
4362            "calls",
4363            "partition_by",
4364            "partitionBy",
4365            "order_by",
4366            "orderBy",
4367            "state_table",
4368            "stateTable",
4369        ];
4370
4371        #[allow(clippy::enum_variant_names)]
4372        enum GeneratedField {
4373            Calls,
4374            PartitionBy,
4375            OrderBy,
4376            StateTable,
4377        }
4378        impl<'de> serde::Deserialize<'de> for GeneratedField {
4379            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4380            where
4381                D: serde::Deserializer<'de>,
4382            {
4383                struct GeneratedVisitor;
4384
4385                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4386                    type Value = GeneratedField;
4387
4388                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4389                        write!(formatter, "expected one of: {:?}", &FIELDS)
4390                    }
4391
4392                    #[allow(unused_variables)]
4393                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4394                    where
4395                        E: serde::de::Error,
4396                    {
4397                        match value {
4398                            "calls" => Ok(GeneratedField::Calls),
4399                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4400                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4401                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4402                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4403                        }
4404                    }
4405                }
4406                deserializer.deserialize_identifier(GeneratedVisitor)
4407            }
4408        }
4409        struct GeneratedVisitor;
4410        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4411            type Value = EowcOverWindowNode;
4412
4413            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4414                formatter.write_str("struct stream_plan.EowcOverWindowNode")
4415            }
4416
4417            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4418                where
4419                    V: serde::de::MapAccess<'de>,
4420            {
4421                let mut calls__ = None;
4422                let mut partition_by__ = None;
4423                let mut order_by__ = None;
4424                let mut state_table__ = None;
4425                while let Some(k) = map_.next_key()? {
4426                    match k {
4427                        GeneratedField::Calls => {
4428                            if calls__.is_some() {
4429                                return Err(serde::de::Error::duplicate_field("calls"));
4430                            }
4431                            calls__ = Some(map_.next_value()?);
4432                        }
4433                        GeneratedField::PartitionBy => {
4434                            if partition_by__.is_some() {
4435                                return Err(serde::de::Error::duplicate_field("partitionBy"));
4436                            }
4437                            partition_by__ = 
4438                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4439                                    .into_iter().map(|x| x.0).collect())
4440                            ;
4441                        }
4442                        GeneratedField::OrderBy => {
4443                            if order_by__.is_some() {
4444                                return Err(serde::de::Error::duplicate_field("orderBy"));
4445                            }
4446                            order_by__ = Some(map_.next_value()?);
4447                        }
4448                        GeneratedField::StateTable => {
4449                            if state_table__.is_some() {
4450                                return Err(serde::de::Error::duplicate_field("stateTable"));
4451                            }
4452                            state_table__ = map_.next_value()?;
4453                        }
4454                    }
4455                }
4456                Ok(EowcOverWindowNode {
4457                    calls: calls__.unwrap_or_default(),
4458                    partition_by: partition_by__.unwrap_or_default(),
4459                    order_by: order_by__.unwrap_or_default(),
4460                    state_table: state_table__,
4461                })
4462            }
4463        }
4464        deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4465    }
4466}
4467impl serde::Serialize for ExchangeNode {
4468    #[allow(deprecated)]
4469    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4470    where
4471        S: serde::Serializer,
4472    {
4473        use serde::ser::SerializeStruct;
4474        let mut len = 0;
4475        if self.strategy.is_some() {
4476            len += 1;
4477        }
4478        let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4479        if let Some(v) = self.strategy.as_ref() {
4480            struct_ser.serialize_field("strategy", v)?;
4481        }
4482        struct_ser.end()
4483    }
4484}
4485impl<'de> serde::Deserialize<'de> for ExchangeNode {
4486    #[allow(deprecated)]
4487    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4488    where
4489        D: serde::Deserializer<'de>,
4490    {
4491        const FIELDS: &[&str] = &[
4492            "strategy",
4493        ];
4494
4495        #[allow(clippy::enum_variant_names)]
4496        enum GeneratedField {
4497            Strategy,
4498        }
4499        impl<'de> serde::Deserialize<'de> for GeneratedField {
4500            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4501            where
4502                D: serde::Deserializer<'de>,
4503            {
4504                struct GeneratedVisitor;
4505
4506                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4507                    type Value = GeneratedField;
4508
4509                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4510                        write!(formatter, "expected one of: {:?}", &FIELDS)
4511                    }
4512
4513                    #[allow(unused_variables)]
4514                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4515                    where
4516                        E: serde::de::Error,
4517                    {
4518                        match value {
4519                            "strategy" => Ok(GeneratedField::Strategy),
4520                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4521                        }
4522                    }
4523                }
4524                deserializer.deserialize_identifier(GeneratedVisitor)
4525            }
4526        }
4527        struct GeneratedVisitor;
4528        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4529            type Value = ExchangeNode;
4530
4531            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4532                formatter.write_str("struct stream_plan.ExchangeNode")
4533            }
4534
4535            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4536                where
4537                    V: serde::de::MapAccess<'de>,
4538            {
4539                let mut strategy__ = None;
4540                while let Some(k) = map_.next_key()? {
4541                    match k {
4542                        GeneratedField::Strategy => {
4543                            if strategy__.is_some() {
4544                                return Err(serde::de::Error::duplicate_field("strategy"));
4545                            }
4546                            strategy__ = map_.next_value()?;
4547                        }
4548                    }
4549                }
4550                Ok(ExchangeNode {
4551                    strategy: strategy__,
4552                })
4553            }
4554        }
4555        deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4556    }
4557}
4558impl serde::Serialize for ExpandNode {
4559    #[allow(deprecated)]
4560    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4561    where
4562        S: serde::Serializer,
4563    {
4564        use serde::ser::SerializeStruct;
4565        let mut len = 0;
4566        if !self.column_subsets.is_empty() {
4567            len += 1;
4568        }
4569        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4570        if !self.column_subsets.is_empty() {
4571            struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4572        }
4573        struct_ser.end()
4574    }
4575}
4576impl<'de> serde::Deserialize<'de> for ExpandNode {
4577    #[allow(deprecated)]
4578    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4579    where
4580        D: serde::Deserializer<'de>,
4581    {
4582        const FIELDS: &[&str] = &[
4583            "column_subsets",
4584            "columnSubsets",
4585        ];
4586
4587        #[allow(clippy::enum_variant_names)]
4588        enum GeneratedField {
4589            ColumnSubsets,
4590        }
4591        impl<'de> serde::Deserialize<'de> for GeneratedField {
4592            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4593            where
4594                D: serde::Deserializer<'de>,
4595            {
4596                struct GeneratedVisitor;
4597
4598                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4599                    type Value = GeneratedField;
4600
4601                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4602                        write!(formatter, "expected one of: {:?}", &FIELDS)
4603                    }
4604
4605                    #[allow(unused_variables)]
4606                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4607                    where
4608                        E: serde::de::Error,
4609                    {
4610                        match value {
4611                            "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4612                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4613                        }
4614                    }
4615                }
4616                deserializer.deserialize_identifier(GeneratedVisitor)
4617            }
4618        }
4619        struct GeneratedVisitor;
4620        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4621            type Value = ExpandNode;
4622
4623            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4624                formatter.write_str("struct stream_plan.ExpandNode")
4625            }
4626
4627            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4628                where
4629                    V: serde::de::MapAccess<'de>,
4630            {
4631                let mut column_subsets__ = None;
4632                while let Some(k) = map_.next_key()? {
4633                    match k {
4634                        GeneratedField::ColumnSubsets => {
4635                            if column_subsets__.is_some() {
4636                                return Err(serde::de::Error::duplicate_field("columnSubsets"));
4637                            }
4638                            column_subsets__ = Some(map_.next_value()?);
4639                        }
4640                    }
4641                }
4642                Ok(ExpandNode {
4643                    column_subsets: column_subsets__.unwrap_or_default(),
4644                })
4645            }
4646        }
4647        deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4648    }
4649}
4650impl serde::Serialize for expand_node::Subset {
4651    #[allow(deprecated)]
4652    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4653    where
4654        S: serde::Serializer,
4655    {
4656        use serde::ser::SerializeStruct;
4657        let mut len = 0;
4658        if !self.column_indices.is_empty() {
4659            len += 1;
4660        }
4661        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4662        if !self.column_indices.is_empty() {
4663            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4664        }
4665        struct_ser.end()
4666    }
4667}
4668impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4669    #[allow(deprecated)]
4670    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4671    where
4672        D: serde::Deserializer<'de>,
4673    {
4674        const FIELDS: &[&str] = &[
4675            "column_indices",
4676            "columnIndices",
4677        ];
4678
4679        #[allow(clippy::enum_variant_names)]
4680        enum GeneratedField {
4681            ColumnIndices,
4682        }
4683        impl<'de> serde::Deserialize<'de> for GeneratedField {
4684            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4685            where
4686                D: serde::Deserializer<'de>,
4687            {
4688                struct GeneratedVisitor;
4689
4690                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4691                    type Value = GeneratedField;
4692
4693                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4694                        write!(formatter, "expected one of: {:?}", &FIELDS)
4695                    }
4696
4697                    #[allow(unused_variables)]
4698                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4699                    where
4700                        E: serde::de::Error,
4701                    {
4702                        match value {
4703                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4704                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4705                        }
4706                    }
4707                }
4708                deserializer.deserialize_identifier(GeneratedVisitor)
4709            }
4710        }
4711        struct GeneratedVisitor;
4712        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4713            type Value = expand_node::Subset;
4714
4715            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4716                formatter.write_str("struct stream_plan.ExpandNode.Subset")
4717            }
4718
4719            fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4720                where
4721                    V: serde::de::MapAccess<'de>,
4722            {
4723                let mut column_indices__ = None;
4724                while let Some(k) = map_.next_key()? {
4725                    match k {
4726                        GeneratedField::ColumnIndices => {
4727                            if column_indices__.is_some() {
4728                                return Err(serde::de::Error::duplicate_field("columnIndices"));
4729                            }
4730                            column_indices__ = 
4731                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4732                                    .into_iter().map(|x| x.0).collect())
4733                            ;
4734                        }
4735                    }
4736                }
4737                Ok(expand_node::Subset {
4738                    column_indices: column_indices__.unwrap_or_default(),
4739                })
4740            }
4741        }
4742        deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4743    }
4744}
4745impl serde::Serialize for FilterNode {
4746    #[allow(deprecated)]
4747    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4748    where
4749        S: serde::Serializer,
4750    {
4751        use serde::ser::SerializeStruct;
4752        let mut len = 0;
4753        if self.search_condition.is_some() {
4754            len += 1;
4755        }
4756        let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4757        if let Some(v) = self.search_condition.as_ref() {
4758            struct_ser.serialize_field("searchCondition", v)?;
4759        }
4760        struct_ser.end()
4761    }
4762}
4763impl<'de> serde::Deserialize<'de> for FilterNode {
4764    #[allow(deprecated)]
4765    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4766    where
4767        D: serde::Deserializer<'de>,
4768    {
4769        const FIELDS: &[&str] = &[
4770            "search_condition",
4771            "searchCondition",
4772        ];
4773
4774        #[allow(clippy::enum_variant_names)]
4775        enum GeneratedField {
4776            SearchCondition,
4777        }
4778        impl<'de> serde::Deserialize<'de> for GeneratedField {
4779            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4780            where
4781                D: serde::Deserializer<'de>,
4782            {
4783                struct GeneratedVisitor;
4784
4785                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4786                    type Value = GeneratedField;
4787
4788                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4789                        write!(formatter, "expected one of: {:?}", &FIELDS)
4790                    }
4791
4792                    #[allow(unused_variables)]
4793                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4794                    where
4795                        E: serde::de::Error,
4796                    {
4797                        match value {
4798                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4799                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4800                        }
4801                    }
4802                }
4803                deserializer.deserialize_identifier(GeneratedVisitor)
4804            }
4805        }
4806        struct GeneratedVisitor;
4807        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4808            type Value = FilterNode;
4809
4810            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4811                formatter.write_str("struct stream_plan.FilterNode")
4812            }
4813
4814            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4815                where
4816                    V: serde::de::MapAccess<'de>,
4817            {
4818                let mut search_condition__ = None;
4819                while let Some(k) = map_.next_key()? {
4820                    match k {
4821                        GeneratedField::SearchCondition => {
4822                            if search_condition__.is_some() {
4823                                return Err(serde::de::Error::duplicate_field("searchCondition"));
4824                            }
4825                            search_condition__ = map_.next_value()?;
4826                        }
4827                    }
4828                }
4829                Ok(FilterNode {
4830                    search_condition: search_condition__,
4831                })
4832            }
4833        }
4834        deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4835    }
4836}
4837impl serde::Serialize for GlobalApproxPercentileNode {
4838    #[allow(deprecated)]
4839    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4840    where
4841        S: serde::Serializer,
4842    {
4843        use serde::ser::SerializeStruct;
4844        let mut len = 0;
4845        if self.base != 0. {
4846            len += 1;
4847        }
4848        if self.quantile != 0. {
4849            len += 1;
4850        }
4851        if self.bucket_state_table.is_some() {
4852            len += 1;
4853        }
4854        if self.count_state_table.is_some() {
4855            len += 1;
4856        }
4857        let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4858        if self.base != 0. {
4859            struct_ser.serialize_field("base", &self.base)?;
4860        }
4861        if self.quantile != 0. {
4862            struct_ser.serialize_field("quantile", &self.quantile)?;
4863        }
4864        if let Some(v) = self.bucket_state_table.as_ref() {
4865            struct_ser.serialize_field("bucketStateTable", v)?;
4866        }
4867        if let Some(v) = self.count_state_table.as_ref() {
4868            struct_ser.serialize_field("countStateTable", v)?;
4869        }
4870        struct_ser.end()
4871    }
4872}
4873impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4874    #[allow(deprecated)]
4875    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4876    where
4877        D: serde::Deserializer<'de>,
4878    {
4879        const FIELDS: &[&str] = &[
4880            "base",
4881            "quantile",
4882            "bucket_state_table",
4883            "bucketStateTable",
4884            "count_state_table",
4885            "countStateTable",
4886        ];
4887
4888        #[allow(clippy::enum_variant_names)]
4889        enum GeneratedField {
4890            Base,
4891            Quantile,
4892            BucketStateTable,
4893            CountStateTable,
4894        }
4895        impl<'de> serde::Deserialize<'de> for GeneratedField {
4896            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4897            where
4898                D: serde::Deserializer<'de>,
4899            {
4900                struct GeneratedVisitor;
4901
4902                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4903                    type Value = GeneratedField;
4904
4905                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4906                        write!(formatter, "expected one of: {:?}", &FIELDS)
4907                    }
4908
4909                    #[allow(unused_variables)]
4910                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4911                    where
4912                        E: serde::de::Error,
4913                    {
4914                        match value {
4915                            "base" => Ok(GeneratedField::Base),
4916                            "quantile" => Ok(GeneratedField::Quantile),
4917                            "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4918                            "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4919                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4920                        }
4921                    }
4922                }
4923                deserializer.deserialize_identifier(GeneratedVisitor)
4924            }
4925        }
4926        struct GeneratedVisitor;
4927        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4928            type Value = GlobalApproxPercentileNode;
4929
4930            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4931                formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4932            }
4933
4934            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4935                where
4936                    V: serde::de::MapAccess<'de>,
4937            {
4938                let mut base__ = None;
4939                let mut quantile__ = None;
4940                let mut bucket_state_table__ = None;
4941                let mut count_state_table__ = None;
4942                while let Some(k) = map_.next_key()? {
4943                    match k {
4944                        GeneratedField::Base => {
4945                            if base__.is_some() {
4946                                return Err(serde::de::Error::duplicate_field("base"));
4947                            }
4948                            base__ = 
4949                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4950                            ;
4951                        }
4952                        GeneratedField::Quantile => {
4953                            if quantile__.is_some() {
4954                                return Err(serde::de::Error::duplicate_field("quantile"));
4955                            }
4956                            quantile__ = 
4957                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4958                            ;
4959                        }
4960                        GeneratedField::BucketStateTable => {
4961                            if bucket_state_table__.is_some() {
4962                                return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4963                            }
4964                            bucket_state_table__ = map_.next_value()?;
4965                        }
4966                        GeneratedField::CountStateTable => {
4967                            if count_state_table__.is_some() {
4968                                return Err(serde::de::Error::duplicate_field("countStateTable"));
4969                            }
4970                            count_state_table__ = map_.next_value()?;
4971                        }
4972                    }
4973                }
4974                Ok(GlobalApproxPercentileNode {
4975                    base: base__.unwrap_or_default(),
4976                    quantile: quantile__.unwrap_or_default(),
4977                    bucket_state_table: bucket_state_table__,
4978                    count_state_table: count_state_table__,
4979                })
4980            }
4981        }
4982        deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4983    }
4984}
4985impl serde::Serialize for GroupTopNNode {
4986    #[allow(deprecated)]
4987    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4988    where
4989        S: serde::Serializer,
4990    {
4991        use serde::ser::SerializeStruct;
4992        let mut len = 0;
4993        if self.limit != 0 {
4994            len += 1;
4995        }
4996        if self.offset != 0 {
4997            len += 1;
4998        }
4999        if !self.group_key.is_empty() {
5000            len += 1;
5001        }
5002        if self.table.is_some() {
5003            len += 1;
5004        }
5005        if !self.order_by.is_empty() {
5006            len += 1;
5007        }
5008        if self.with_ties {
5009            len += 1;
5010        }
5011        let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5012        if self.limit != 0 {
5013            #[allow(clippy::needless_borrow)]
5014            #[allow(clippy::needless_borrows_for_generic_args)]
5015            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5016        }
5017        if self.offset != 0 {
5018            #[allow(clippy::needless_borrow)]
5019            #[allow(clippy::needless_borrows_for_generic_args)]
5020            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5021        }
5022        if !self.group_key.is_empty() {
5023            struct_ser.serialize_field("groupKey", &self.group_key)?;
5024        }
5025        if let Some(v) = self.table.as_ref() {
5026            struct_ser.serialize_field("table", v)?;
5027        }
5028        if !self.order_by.is_empty() {
5029            struct_ser.serialize_field("orderBy", &self.order_by)?;
5030        }
5031        if self.with_ties {
5032            struct_ser.serialize_field("withTies", &self.with_ties)?;
5033        }
5034        struct_ser.end()
5035    }
5036}
5037impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5038    #[allow(deprecated)]
5039    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5040    where
5041        D: serde::Deserializer<'de>,
5042    {
5043        const FIELDS: &[&str] = &[
5044            "limit",
5045            "offset",
5046            "group_key",
5047            "groupKey",
5048            "table",
5049            "order_by",
5050            "orderBy",
5051            "with_ties",
5052            "withTies",
5053        ];
5054
5055        #[allow(clippy::enum_variant_names)]
5056        enum GeneratedField {
5057            Limit,
5058            Offset,
5059            GroupKey,
5060            Table,
5061            OrderBy,
5062            WithTies,
5063        }
5064        impl<'de> serde::Deserialize<'de> for GeneratedField {
5065            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5066            where
5067                D: serde::Deserializer<'de>,
5068            {
5069                struct GeneratedVisitor;
5070
5071                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5072                    type Value = GeneratedField;
5073
5074                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5075                        write!(formatter, "expected one of: {:?}", &FIELDS)
5076                    }
5077
5078                    #[allow(unused_variables)]
5079                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5080                    where
5081                        E: serde::de::Error,
5082                    {
5083                        match value {
5084                            "limit" => Ok(GeneratedField::Limit),
5085                            "offset" => Ok(GeneratedField::Offset),
5086                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5087                            "table" => Ok(GeneratedField::Table),
5088                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5089                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5090                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5091                        }
5092                    }
5093                }
5094                deserializer.deserialize_identifier(GeneratedVisitor)
5095            }
5096        }
5097        struct GeneratedVisitor;
5098        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5099            type Value = GroupTopNNode;
5100
5101            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5102                formatter.write_str("struct stream_plan.GroupTopNNode")
5103            }
5104
5105            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5106                where
5107                    V: serde::de::MapAccess<'de>,
5108            {
5109                let mut limit__ = None;
5110                let mut offset__ = None;
5111                let mut group_key__ = None;
5112                let mut table__ = None;
5113                let mut order_by__ = None;
5114                let mut with_ties__ = None;
5115                while let Some(k) = map_.next_key()? {
5116                    match k {
5117                        GeneratedField::Limit => {
5118                            if limit__.is_some() {
5119                                return Err(serde::de::Error::duplicate_field("limit"));
5120                            }
5121                            limit__ = 
5122                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5123                            ;
5124                        }
5125                        GeneratedField::Offset => {
5126                            if offset__.is_some() {
5127                                return Err(serde::de::Error::duplicate_field("offset"));
5128                            }
5129                            offset__ = 
5130                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5131                            ;
5132                        }
5133                        GeneratedField::GroupKey => {
5134                            if group_key__.is_some() {
5135                                return Err(serde::de::Error::duplicate_field("groupKey"));
5136                            }
5137                            group_key__ = 
5138                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5139                                    .into_iter().map(|x| x.0).collect())
5140                            ;
5141                        }
5142                        GeneratedField::Table => {
5143                            if table__.is_some() {
5144                                return Err(serde::de::Error::duplicate_field("table"));
5145                            }
5146                            table__ = map_.next_value()?;
5147                        }
5148                        GeneratedField::OrderBy => {
5149                            if order_by__.is_some() {
5150                                return Err(serde::de::Error::duplicate_field("orderBy"));
5151                            }
5152                            order_by__ = Some(map_.next_value()?);
5153                        }
5154                        GeneratedField::WithTies => {
5155                            if with_ties__.is_some() {
5156                                return Err(serde::de::Error::duplicate_field("withTies"));
5157                            }
5158                            with_ties__ = Some(map_.next_value()?);
5159                        }
5160                    }
5161                }
5162                Ok(GroupTopNNode {
5163                    limit: limit__.unwrap_or_default(),
5164                    offset: offset__.unwrap_or_default(),
5165                    group_key: group_key__.unwrap_or_default(),
5166                    table: table__,
5167                    order_by: order_by__.unwrap_or_default(),
5168                    with_ties: with_ties__.unwrap_or_default(),
5169                })
5170            }
5171        }
5172        deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5173    }
5174}
5175impl serde::Serialize for HashAggNode {
5176    #[allow(deprecated)]
5177    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5178    where
5179        S: serde::Serializer,
5180    {
5181        use serde::ser::SerializeStruct;
5182        let mut len = 0;
5183        if !self.group_key.is_empty() {
5184            len += 1;
5185        }
5186        if !self.agg_calls.is_empty() {
5187            len += 1;
5188        }
5189        if !self.agg_call_states.is_empty() {
5190            len += 1;
5191        }
5192        if self.intermediate_state_table.is_some() {
5193            len += 1;
5194        }
5195        if self.is_append_only {
5196            len += 1;
5197        }
5198        if !self.distinct_dedup_tables.is_empty() {
5199            len += 1;
5200        }
5201        if self.row_count_index != 0 {
5202            len += 1;
5203        }
5204        if self.emit_on_window_close {
5205            len += 1;
5206        }
5207        if self.version != 0 {
5208            len += 1;
5209        }
5210        let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5211        if !self.group_key.is_empty() {
5212            struct_ser.serialize_field("groupKey", &self.group_key)?;
5213        }
5214        if !self.agg_calls.is_empty() {
5215            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5216        }
5217        if !self.agg_call_states.is_empty() {
5218            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5219        }
5220        if let Some(v) = self.intermediate_state_table.as_ref() {
5221            struct_ser.serialize_field("intermediateStateTable", v)?;
5222        }
5223        if self.is_append_only {
5224            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5225        }
5226        if !self.distinct_dedup_tables.is_empty() {
5227            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5228        }
5229        if self.row_count_index != 0 {
5230            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5231        }
5232        if self.emit_on_window_close {
5233            struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5234        }
5235        if self.version != 0 {
5236            let v = AggNodeVersion::try_from(self.version)
5237                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5238            struct_ser.serialize_field("version", &v)?;
5239        }
5240        struct_ser.end()
5241    }
5242}
5243impl<'de> serde::Deserialize<'de> for HashAggNode {
5244    #[allow(deprecated)]
5245    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5246    where
5247        D: serde::Deserializer<'de>,
5248    {
5249        const FIELDS: &[&str] = &[
5250            "group_key",
5251            "groupKey",
5252            "agg_calls",
5253            "aggCalls",
5254            "agg_call_states",
5255            "aggCallStates",
5256            "intermediate_state_table",
5257            "intermediateStateTable",
5258            "is_append_only",
5259            "isAppendOnly",
5260            "distinct_dedup_tables",
5261            "distinctDedupTables",
5262            "row_count_index",
5263            "rowCountIndex",
5264            "emit_on_window_close",
5265            "emitOnWindowClose",
5266            "version",
5267        ];
5268
5269        #[allow(clippy::enum_variant_names)]
5270        enum GeneratedField {
5271            GroupKey,
5272            AggCalls,
5273            AggCallStates,
5274            IntermediateStateTable,
5275            IsAppendOnly,
5276            DistinctDedupTables,
5277            RowCountIndex,
5278            EmitOnWindowClose,
5279            Version,
5280        }
5281        impl<'de> serde::Deserialize<'de> for GeneratedField {
5282            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5283            where
5284                D: serde::Deserializer<'de>,
5285            {
5286                struct GeneratedVisitor;
5287
5288                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5289                    type Value = GeneratedField;
5290
5291                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5292                        write!(formatter, "expected one of: {:?}", &FIELDS)
5293                    }
5294
5295                    #[allow(unused_variables)]
5296                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5297                    where
5298                        E: serde::de::Error,
5299                    {
5300                        match value {
5301                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5302                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5303                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5304                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5305                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5306                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5307                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5308                            "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5309                            "version" => Ok(GeneratedField::Version),
5310                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5311                        }
5312                    }
5313                }
5314                deserializer.deserialize_identifier(GeneratedVisitor)
5315            }
5316        }
5317        struct GeneratedVisitor;
5318        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5319            type Value = HashAggNode;
5320
5321            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5322                formatter.write_str("struct stream_plan.HashAggNode")
5323            }
5324
5325            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5326                where
5327                    V: serde::de::MapAccess<'de>,
5328            {
5329                let mut group_key__ = None;
5330                let mut agg_calls__ = None;
5331                let mut agg_call_states__ = None;
5332                let mut intermediate_state_table__ = None;
5333                let mut is_append_only__ = None;
5334                let mut distinct_dedup_tables__ = None;
5335                let mut row_count_index__ = None;
5336                let mut emit_on_window_close__ = None;
5337                let mut version__ = None;
5338                while let Some(k) = map_.next_key()? {
5339                    match k {
5340                        GeneratedField::GroupKey => {
5341                            if group_key__.is_some() {
5342                                return Err(serde::de::Error::duplicate_field("groupKey"));
5343                            }
5344                            group_key__ = 
5345                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5346                                    .into_iter().map(|x| x.0).collect())
5347                            ;
5348                        }
5349                        GeneratedField::AggCalls => {
5350                            if agg_calls__.is_some() {
5351                                return Err(serde::de::Error::duplicate_field("aggCalls"));
5352                            }
5353                            agg_calls__ = Some(map_.next_value()?);
5354                        }
5355                        GeneratedField::AggCallStates => {
5356                            if agg_call_states__.is_some() {
5357                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
5358                            }
5359                            agg_call_states__ = Some(map_.next_value()?);
5360                        }
5361                        GeneratedField::IntermediateStateTable => {
5362                            if intermediate_state_table__.is_some() {
5363                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5364                            }
5365                            intermediate_state_table__ = map_.next_value()?;
5366                        }
5367                        GeneratedField::IsAppendOnly => {
5368                            if is_append_only__.is_some() {
5369                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5370                            }
5371                            is_append_only__ = Some(map_.next_value()?);
5372                        }
5373                        GeneratedField::DistinctDedupTables => {
5374                            if distinct_dedup_tables__.is_some() {
5375                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5376                            }
5377                            distinct_dedup_tables__ = Some(
5378                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5379                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5380                            );
5381                        }
5382                        GeneratedField::RowCountIndex => {
5383                            if row_count_index__.is_some() {
5384                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5385                            }
5386                            row_count_index__ = 
5387                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5388                            ;
5389                        }
5390                        GeneratedField::EmitOnWindowClose => {
5391                            if emit_on_window_close__.is_some() {
5392                                return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5393                            }
5394                            emit_on_window_close__ = Some(map_.next_value()?);
5395                        }
5396                        GeneratedField::Version => {
5397                            if version__.is_some() {
5398                                return Err(serde::de::Error::duplicate_field("version"));
5399                            }
5400                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5401                        }
5402                    }
5403                }
5404                Ok(HashAggNode {
5405                    group_key: group_key__.unwrap_or_default(),
5406                    agg_calls: agg_calls__.unwrap_or_default(),
5407                    agg_call_states: agg_call_states__.unwrap_or_default(),
5408                    intermediate_state_table: intermediate_state_table__,
5409                    is_append_only: is_append_only__.unwrap_or_default(),
5410                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5411                    row_count_index: row_count_index__.unwrap_or_default(),
5412                    emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5413                    version: version__.unwrap_or_default(),
5414                })
5415            }
5416        }
5417        deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5418    }
5419}
5420impl serde::Serialize for HashJoinNode {
5421    #[allow(deprecated)]
5422    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5423    where
5424        S: serde::Serializer,
5425    {
5426        use serde::ser::SerializeStruct;
5427        let mut len = 0;
5428        if self.join_type != 0 {
5429            len += 1;
5430        }
5431        if !self.left_key.is_empty() {
5432            len += 1;
5433        }
5434        if !self.right_key.is_empty() {
5435            len += 1;
5436        }
5437        if self.condition.is_some() {
5438            len += 1;
5439        }
5440        if !self.inequality_pairs.is_empty() {
5441            len += 1;
5442        }
5443        if self.left_table.is_some() {
5444            len += 1;
5445        }
5446        if self.right_table.is_some() {
5447            len += 1;
5448        }
5449        if self.left_degree_table.is_some() {
5450            len += 1;
5451        }
5452        if self.right_degree_table.is_some() {
5453            len += 1;
5454        }
5455        if !self.output_indices.is_empty() {
5456            len += 1;
5457        }
5458        if !self.left_deduped_input_pk_indices.is_empty() {
5459            len += 1;
5460        }
5461        if !self.right_deduped_input_pk_indices.is_empty() {
5462            len += 1;
5463        }
5464        if !self.null_safe.is_empty() {
5465            len += 1;
5466        }
5467        if self.is_append_only {
5468            len += 1;
5469        }
5470        if self.join_encoding_type != 0 {
5471            len += 1;
5472        }
5473        let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5474        if self.join_type != 0 {
5475            let v = super::plan_common::JoinType::try_from(self.join_type)
5476                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5477            struct_ser.serialize_field("joinType", &v)?;
5478        }
5479        if !self.left_key.is_empty() {
5480            struct_ser.serialize_field("leftKey", &self.left_key)?;
5481        }
5482        if !self.right_key.is_empty() {
5483            struct_ser.serialize_field("rightKey", &self.right_key)?;
5484        }
5485        if let Some(v) = self.condition.as_ref() {
5486            struct_ser.serialize_field("condition", v)?;
5487        }
5488        if !self.inequality_pairs.is_empty() {
5489            struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5490        }
5491        if let Some(v) = self.left_table.as_ref() {
5492            struct_ser.serialize_field("leftTable", v)?;
5493        }
5494        if let Some(v) = self.right_table.as_ref() {
5495            struct_ser.serialize_field("rightTable", v)?;
5496        }
5497        if let Some(v) = self.left_degree_table.as_ref() {
5498            struct_ser.serialize_field("leftDegreeTable", v)?;
5499        }
5500        if let Some(v) = self.right_degree_table.as_ref() {
5501            struct_ser.serialize_field("rightDegreeTable", v)?;
5502        }
5503        if !self.output_indices.is_empty() {
5504            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5505        }
5506        if !self.left_deduped_input_pk_indices.is_empty() {
5507            struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5508        }
5509        if !self.right_deduped_input_pk_indices.is_empty() {
5510            struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5511        }
5512        if !self.null_safe.is_empty() {
5513            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5514        }
5515        if self.is_append_only {
5516            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5517        }
5518        if self.join_encoding_type != 0 {
5519            let v = JoinEncodingType::try_from(self.join_encoding_type)
5520                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5521            struct_ser.serialize_field("joinEncodingType", &v)?;
5522        }
5523        struct_ser.end()
5524    }
5525}
5526impl<'de> serde::Deserialize<'de> for HashJoinNode {
5527    #[allow(deprecated)]
5528    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5529    where
5530        D: serde::Deserializer<'de>,
5531    {
5532        const FIELDS: &[&str] = &[
5533            "join_type",
5534            "joinType",
5535            "left_key",
5536            "leftKey",
5537            "right_key",
5538            "rightKey",
5539            "condition",
5540            "inequality_pairs",
5541            "inequalityPairs",
5542            "left_table",
5543            "leftTable",
5544            "right_table",
5545            "rightTable",
5546            "left_degree_table",
5547            "leftDegreeTable",
5548            "right_degree_table",
5549            "rightDegreeTable",
5550            "output_indices",
5551            "outputIndices",
5552            "left_deduped_input_pk_indices",
5553            "leftDedupedInputPkIndices",
5554            "right_deduped_input_pk_indices",
5555            "rightDedupedInputPkIndices",
5556            "null_safe",
5557            "nullSafe",
5558            "is_append_only",
5559            "isAppendOnly",
5560            "join_encoding_type",
5561            "joinEncodingType",
5562        ];
5563
5564        #[allow(clippy::enum_variant_names)]
5565        enum GeneratedField {
5566            JoinType,
5567            LeftKey,
5568            RightKey,
5569            Condition,
5570            InequalityPairs,
5571            LeftTable,
5572            RightTable,
5573            LeftDegreeTable,
5574            RightDegreeTable,
5575            OutputIndices,
5576            LeftDedupedInputPkIndices,
5577            RightDedupedInputPkIndices,
5578            NullSafe,
5579            IsAppendOnly,
5580            JoinEncodingType,
5581        }
5582        impl<'de> serde::Deserialize<'de> for GeneratedField {
5583            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5584            where
5585                D: serde::Deserializer<'de>,
5586            {
5587                struct GeneratedVisitor;
5588
5589                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5590                    type Value = GeneratedField;
5591
5592                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5593                        write!(formatter, "expected one of: {:?}", &FIELDS)
5594                    }
5595
5596                    #[allow(unused_variables)]
5597                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5598                    where
5599                        E: serde::de::Error,
5600                    {
5601                        match value {
5602                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5603                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5604                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5605                            "condition" => Ok(GeneratedField::Condition),
5606                            "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5607                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5608                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5609                            "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5610                            "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5611                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5612                            "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5613                            "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5614                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5615                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5616                            "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5617                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5618                        }
5619                    }
5620                }
5621                deserializer.deserialize_identifier(GeneratedVisitor)
5622            }
5623        }
5624        struct GeneratedVisitor;
5625        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5626            type Value = HashJoinNode;
5627
5628            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5629                formatter.write_str("struct stream_plan.HashJoinNode")
5630            }
5631
5632            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5633                where
5634                    V: serde::de::MapAccess<'de>,
5635            {
5636                let mut join_type__ = None;
5637                let mut left_key__ = None;
5638                let mut right_key__ = None;
5639                let mut condition__ = None;
5640                let mut inequality_pairs__ = None;
5641                let mut left_table__ = None;
5642                let mut right_table__ = None;
5643                let mut left_degree_table__ = None;
5644                let mut right_degree_table__ = None;
5645                let mut output_indices__ = None;
5646                let mut left_deduped_input_pk_indices__ = None;
5647                let mut right_deduped_input_pk_indices__ = None;
5648                let mut null_safe__ = None;
5649                let mut is_append_only__ = None;
5650                let mut join_encoding_type__ = None;
5651                while let Some(k) = map_.next_key()? {
5652                    match k {
5653                        GeneratedField::JoinType => {
5654                            if join_type__.is_some() {
5655                                return Err(serde::de::Error::duplicate_field("joinType"));
5656                            }
5657                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5658                        }
5659                        GeneratedField::LeftKey => {
5660                            if left_key__.is_some() {
5661                                return Err(serde::de::Error::duplicate_field("leftKey"));
5662                            }
5663                            left_key__ = 
5664                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5665                                    .into_iter().map(|x| x.0).collect())
5666                            ;
5667                        }
5668                        GeneratedField::RightKey => {
5669                            if right_key__.is_some() {
5670                                return Err(serde::de::Error::duplicate_field("rightKey"));
5671                            }
5672                            right_key__ = 
5673                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5674                                    .into_iter().map(|x| x.0).collect())
5675                            ;
5676                        }
5677                        GeneratedField::Condition => {
5678                            if condition__.is_some() {
5679                                return Err(serde::de::Error::duplicate_field("condition"));
5680                            }
5681                            condition__ = map_.next_value()?;
5682                        }
5683                        GeneratedField::InequalityPairs => {
5684                            if inequality_pairs__.is_some() {
5685                                return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5686                            }
5687                            inequality_pairs__ = Some(map_.next_value()?);
5688                        }
5689                        GeneratedField::LeftTable => {
5690                            if left_table__.is_some() {
5691                                return Err(serde::de::Error::duplicate_field("leftTable"));
5692                            }
5693                            left_table__ = map_.next_value()?;
5694                        }
5695                        GeneratedField::RightTable => {
5696                            if right_table__.is_some() {
5697                                return Err(serde::de::Error::duplicate_field("rightTable"));
5698                            }
5699                            right_table__ = map_.next_value()?;
5700                        }
5701                        GeneratedField::LeftDegreeTable => {
5702                            if left_degree_table__.is_some() {
5703                                return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5704                            }
5705                            left_degree_table__ = map_.next_value()?;
5706                        }
5707                        GeneratedField::RightDegreeTable => {
5708                            if right_degree_table__.is_some() {
5709                                return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5710                            }
5711                            right_degree_table__ = map_.next_value()?;
5712                        }
5713                        GeneratedField::OutputIndices => {
5714                            if output_indices__.is_some() {
5715                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5716                            }
5717                            output_indices__ = 
5718                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5719                                    .into_iter().map(|x| x.0).collect())
5720                            ;
5721                        }
5722                        GeneratedField::LeftDedupedInputPkIndices => {
5723                            if left_deduped_input_pk_indices__.is_some() {
5724                                return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5725                            }
5726                            left_deduped_input_pk_indices__ = 
5727                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5728                                    .into_iter().map(|x| x.0).collect())
5729                            ;
5730                        }
5731                        GeneratedField::RightDedupedInputPkIndices => {
5732                            if right_deduped_input_pk_indices__.is_some() {
5733                                return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5734                            }
5735                            right_deduped_input_pk_indices__ = 
5736                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5737                                    .into_iter().map(|x| x.0).collect())
5738                            ;
5739                        }
5740                        GeneratedField::NullSafe => {
5741                            if null_safe__.is_some() {
5742                                return Err(serde::de::Error::duplicate_field("nullSafe"));
5743                            }
5744                            null_safe__ = Some(map_.next_value()?);
5745                        }
5746                        GeneratedField::IsAppendOnly => {
5747                            if is_append_only__.is_some() {
5748                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5749                            }
5750                            is_append_only__ = Some(map_.next_value()?);
5751                        }
5752                        GeneratedField::JoinEncodingType => {
5753                            if join_encoding_type__.is_some() {
5754                                return Err(serde::de::Error::duplicate_field("joinEncodingType"));
5755                            }
5756                            join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
5757                        }
5758                    }
5759                }
5760                Ok(HashJoinNode {
5761                    join_type: join_type__.unwrap_or_default(),
5762                    left_key: left_key__.unwrap_or_default(),
5763                    right_key: right_key__.unwrap_or_default(),
5764                    condition: condition__,
5765                    inequality_pairs: inequality_pairs__.unwrap_or_default(),
5766                    left_table: left_table__,
5767                    right_table: right_table__,
5768                    left_degree_table: left_degree_table__,
5769                    right_degree_table: right_degree_table__,
5770                    output_indices: output_indices__.unwrap_or_default(),
5771                    left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5772                    right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5773                    null_safe: null_safe__.unwrap_or_default(),
5774                    is_append_only: is_append_only__.unwrap_or_default(),
5775                    join_encoding_type: join_encoding_type__.unwrap_or_default(),
5776                })
5777            }
5778        }
5779        deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5780    }
5781}
5782impl serde::Serialize for HopWindowNode {
5783    #[allow(deprecated)]
5784    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5785    where
5786        S: serde::Serializer,
5787    {
5788        use serde::ser::SerializeStruct;
5789        let mut len = 0;
5790        if self.time_col != 0 {
5791            len += 1;
5792        }
5793        if self.window_slide.is_some() {
5794            len += 1;
5795        }
5796        if self.window_size.is_some() {
5797            len += 1;
5798        }
5799        if !self.output_indices.is_empty() {
5800            len += 1;
5801        }
5802        if !self.window_start_exprs.is_empty() {
5803            len += 1;
5804        }
5805        if !self.window_end_exprs.is_empty() {
5806            len += 1;
5807        }
5808        let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5809        if self.time_col != 0 {
5810            struct_ser.serialize_field("timeCol", &self.time_col)?;
5811        }
5812        if let Some(v) = self.window_slide.as_ref() {
5813            struct_ser.serialize_field("windowSlide", v)?;
5814        }
5815        if let Some(v) = self.window_size.as_ref() {
5816            struct_ser.serialize_field("windowSize", v)?;
5817        }
5818        if !self.output_indices.is_empty() {
5819            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5820        }
5821        if !self.window_start_exprs.is_empty() {
5822            struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5823        }
5824        if !self.window_end_exprs.is_empty() {
5825            struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5826        }
5827        struct_ser.end()
5828    }
5829}
5830impl<'de> serde::Deserialize<'de> for HopWindowNode {
5831    #[allow(deprecated)]
5832    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5833    where
5834        D: serde::Deserializer<'de>,
5835    {
5836        const FIELDS: &[&str] = &[
5837            "time_col",
5838            "timeCol",
5839            "window_slide",
5840            "windowSlide",
5841            "window_size",
5842            "windowSize",
5843            "output_indices",
5844            "outputIndices",
5845            "window_start_exprs",
5846            "windowStartExprs",
5847            "window_end_exprs",
5848            "windowEndExprs",
5849        ];
5850
5851        #[allow(clippy::enum_variant_names)]
5852        enum GeneratedField {
5853            TimeCol,
5854            WindowSlide,
5855            WindowSize,
5856            OutputIndices,
5857            WindowStartExprs,
5858            WindowEndExprs,
5859        }
5860        impl<'de> serde::Deserialize<'de> for GeneratedField {
5861            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5862            where
5863                D: serde::Deserializer<'de>,
5864            {
5865                struct GeneratedVisitor;
5866
5867                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5868                    type Value = GeneratedField;
5869
5870                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5871                        write!(formatter, "expected one of: {:?}", &FIELDS)
5872                    }
5873
5874                    #[allow(unused_variables)]
5875                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5876                    where
5877                        E: serde::de::Error,
5878                    {
5879                        match value {
5880                            "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5881                            "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5882                            "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5883                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5884                            "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5885                            "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5886                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5887                        }
5888                    }
5889                }
5890                deserializer.deserialize_identifier(GeneratedVisitor)
5891            }
5892        }
5893        struct GeneratedVisitor;
5894        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5895            type Value = HopWindowNode;
5896
5897            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5898                formatter.write_str("struct stream_plan.HopWindowNode")
5899            }
5900
5901            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5902                where
5903                    V: serde::de::MapAccess<'de>,
5904            {
5905                let mut time_col__ = None;
5906                let mut window_slide__ = None;
5907                let mut window_size__ = None;
5908                let mut output_indices__ = None;
5909                let mut window_start_exprs__ = None;
5910                let mut window_end_exprs__ = None;
5911                while let Some(k) = map_.next_key()? {
5912                    match k {
5913                        GeneratedField::TimeCol => {
5914                            if time_col__.is_some() {
5915                                return Err(serde::de::Error::duplicate_field("timeCol"));
5916                            }
5917                            time_col__ = 
5918                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5919                            ;
5920                        }
5921                        GeneratedField::WindowSlide => {
5922                            if window_slide__.is_some() {
5923                                return Err(serde::de::Error::duplicate_field("windowSlide"));
5924                            }
5925                            window_slide__ = map_.next_value()?;
5926                        }
5927                        GeneratedField::WindowSize => {
5928                            if window_size__.is_some() {
5929                                return Err(serde::de::Error::duplicate_field("windowSize"));
5930                            }
5931                            window_size__ = map_.next_value()?;
5932                        }
5933                        GeneratedField::OutputIndices => {
5934                            if output_indices__.is_some() {
5935                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5936                            }
5937                            output_indices__ = 
5938                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5939                                    .into_iter().map(|x| x.0).collect())
5940                            ;
5941                        }
5942                        GeneratedField::WindowStartExprs => {
5943                            if window_start_exprs__.is_some() {
5944                                return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5945                            }
5946                            window_start_exprs__ = Some(map_.next_value()?);
5947                        }
5948                        GeneratedField::WindowEndExprs => {
5949                            if window_end_exprs__.is_some() {
5950                                return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5951                            }
5952                            window_end_exprs__ = Some(map_.next_value()?);
5953                        }
5954                    }
5955                }
5956                Ok(HopWindowNode {
5957                    time_col: time_col__.unwrap_or_default(),
5958                    window_slide: window_slide__,
5959                    window_size: window_size__,
5960                    output_indices: output_indices__.unwrap_or_default(),
5961                    window_start_exprs: window_start_exprs__.unwrap_or_default(),
5962                    window_end_exprs: window_end_exprs__.unwrap_or_default(),
5963                })
5964            }
5965        }
5966        deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5967    }
5968}
5969impl serde::Serialize for InequalityPair {
5970    #[allow(deprecated)]
5971    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5972    where
5973        S: serde::Serializer,
5974    {
5975        use serde::ser::SerializeStruct;
5976        let mut len = 0;
5977        if self.key_required_larger != 0 {
5978            len += 1;
5979        }
5980        if self.key_required_smaller != 0 {
5981            len += 1;
5982        }
5983        if self.clean_state {
5984            len += 1;
5985        }
5986        if self.delta_expression.is_some() {
5987            len += 1;
5988        }
5989        let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5990        if self.key_required_larger != 0 {
5991            struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5992        }
5993        if self.key_required_smaller != 0 {
5994            struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5995        }
5996        if self.clean_state {
5997            struct_ser.serialize_field("cleanState", &self.clean_state)?;
5998        }
5999        if let Some(v) = self.delta_expression.as_ref() {
6000            struct_ser.serialize_field("deltaExpression", v)?;
6001        }
6002        struct_ser.end()
6003    }
6004}
6005impl<'de> serde::Deserialize<'de> for InequalityPair {
6006    #[allow(deprecated)]
6007    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6008    where
6009        D: serde::Deserializer<'de>,
6010    {
6011        const FIELDS: &[&str] = &[
6012            "key_required_larger",
6013            "keyRequiredLarger",
6014            "key_required_smaller",
6015            "keyRequiredSmaller",
6016            "clean_state",
6017            "cleanState",
6018            "delta_expression",
6019            "deltaExpression",
6020        ];
6021
6022        #[allow(clippy::enum_variant_names)]
6023        enum GeneratedField {
6024            KeyRequiredLarger,
6025            KeyRequiredSmaller,
6026            CleanState,
6027            DeltaExpression,
6028        }
6029        impl<'de> serde::Deserialize<'de> for GeneratedField {
6030            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6031            where
6032                D: serde::Deserializer<'de>,
6033            {
6034                struct GeneratedVisitor;
6035
6036                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6037                    type Value = GeneratedField;
6038
6039                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6040                        write!(formatter, "expected one of: {:?}", &FIELDS)
6041                    }
6042
6043                    #[allow(unused_variables)]
6044                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6045                    where
6046                        E: serde::de::Error,
6047                    {
6048                        match value {
6049                            "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6050                            "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6051                            "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6052                            "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6053                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6054                        }
6055                    }
6056                }
6057                deserializer.deserialize_identifier(GeneratedVisitor)
6058            }
6059        }
6060        struct GeneratedVisitor;
6061        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6062            type Value = InequalityPair;
6063
6064            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6065                formatter.write_str("struct stream_plan.InequalityPair")
6066            }
6067
6068            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6069                where
6070                    V: serde::de::MapAccess<'de>,
6071            {
6072                let mut key_required_larger__ = None;
6073                let mut key_required_smaller__ = None;
6074                let mut clean_state__ = None;
6075                let mut delta_expression__ = None;
6076                while let Some(k) = map_.next_key()? {
6077                    match k {
6078                        GeneratedField::KeyRequiredLarger => {
6079                            if key_required_larger__.is_some() {
6080                                return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6081                            }
6082                            key_required_larger__ = 
6083                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6084                            ;
6085                        }
6086                        GeneratedField::KeyRequiredSmaller => {
6087                            if key_required_smaller__.is_some() {
6088                                return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6089                            }
6090                            key_required_smaller__ = 
6091                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6092                            ;
6093                        }
6094                        GeneratedField::CleanState => {
6095                            if clean_state__.is_some() {
6096                                return Err(serde::de::Error::duplicate_field("cleanState"));
6097                            }
6098                            clean_state__ = Some(map_.next_value()?);
6099                        }
6100                        GeneratedField::DeltaExpression => {
6101                            if delta_expression__.is_some() {
6102                                return Err(serde::de::Error::duplicate_field("deltaExpression"));
6103                            }
6104                            delta_expression__ = map_.next_value()?;
6105                        }
6106                    }
6107                }
6108                Ok(InequalityPair {
6109                    key_required_larger: key_required_larger__.unwrap_or_default(),
6110                    key_required_smaller: key_required_smaller__.unwrap_or_default(),
6111                    clean_state: clean_state__.unwrap_or_default(),
6112                    delta_expression: delta_expression__,
6113                })
6114            }
6115        }
6116        deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6117    }
6118}
6119impl serde::Serialize for JoinEncodingType {
6120    #[allow(deprecated)]
6121    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6122    where
6123        S: serde::Serializer,
6124    {
6125        let variant = match self {
6126            Self::Unspecified => "UNSPECIFIED",
6127            Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6128            Self::CpuOptimized => "CPU_OPTIMIZED",
6129        };
6130        serializer.serialize_str(variant)
6131    }
6132}
6133impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6134    #[allow(deprecated)]
6135    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6136    where
6137        D: serde::Deserializer<'de>,
6138    {
6139        const FIELDS: &[&str] = &[
6140            "UNSPECIFIED",
6141            "MEMORY_OPTIMIZED",
6142            "CPU_OPTIMIZED",
6143        ];
6144
6145        struct GeneratedVisitor;
6146
6147        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6148            type Value = JoinEncodingType;
6149
6150            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6151                write!(formatter, "expected one of: {:?}", &FIELDS)
6152            }
6153
6154            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6155            where
6156                E: serde::de::Error,
6157            {
6158                i32::try_from(v)
6159                    .ok()
6160                    .and_then(|x| x.try_into().ok())
6161                    .ok_or_else(|| {
6162                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6163                    })
6164            }
6165
6166            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6167            where
6168                E: serde::de::Error,
6169            {
6170                i32::try_from(v)
6171                    .ok()
6172                    .and_then(|x| x.try_into().ok())
6173                    .ok_or_else(|| {
6174                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6175                    })
6176            }
6177
6178            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6179            where
6180                E: serde::de::Error,
6181            {
6182                match value {
6183                    "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6184                    "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6185                    "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6186                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6187                }
6188            }
6189        }
6190        deserializer.deserialize_any(GeneratedVisitor)
6191    }
6192}
6193impl serde::Serialize for LoadFinishMutation {
6194    #[allow(deprecated)]
6195    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6196    where
6197        S: serde::Serializer,
6198    {
6199        use serde::ser::SerializeStruct;
6200        let mut len = 0;
6201        if self.associated_source_id != 0 {
6202            len += 1;
6203        }
6204        let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6205        if self.associated_source_id != 0 {
6206            struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6207        }
6208        struct_ser.end()
6209    }
6210}
6211impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6212    #[allow(deprecated)]
6213    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6214    where
6215        D: serde::Deserializer<'de>,
6216    {
6217        const FIELDS: &[&str] = &[
6218            "associated_source_id",
6219            "associatedSourceId",
6220        ];
6221
6222        #[allow(clippy::enum_variant_names)]
6223        enum GeneratedField {
6224            AssociatedSourceId,
6225        }
6226        impl<'de> serde::Deserialize<'de> for GeneratedField {
6227            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6228            where
6229                D: serde::Deserializer<'de>,
6230            {
6231                struct GeneratedVisitor;
6232
6233                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6234                    type Value = GeneratedField;
6235
6236                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6237                        write!(formatter, "expected one of: {:?}", &FIELDS)
6238                    }
6239
6240                    #[allow(unused_variables)]
6241                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6242                    where
6243                        E: serde::de::Error,
6244                    {
6245                        match value {
6246                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6247                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6248                        }
6249                    }
6250                }
6251                deserializer.deserialize_identifier(GeneratedVisitor)
6252            }
6253        }
6254        struct GeneratedVisitor;
6255        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6256            type Value = LoadFinishMutation;
6257
6258            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6259                formatter.write_str("struct stream_plan.LoadFinishMutation")
6260            }
6261
6262            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6263                where
6264                    V: serde::de::MapAccess<'de>,
6265            {
6266                let mut associated_source_id__ = None;
6267                while let Some(k) = map_.next_key()? {
6268                    match k {
6269                        GeneratedField::AssociatedSourceId => {
6270                            if associated_source_id__.is_some() {
6271                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6272                            }
6273                            associated_source_id__ = 
6274                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6275                            ;
6276                        }
6277                    }
6278                }
6279                Ok(LoadFinishMutation {
6280                    associated_source_id: associated_source_id__.unwrap_or_default(),
6281                })
6282            }
6283        }
6284        deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6285    }
6286}
6287impl serde::Serialize for LocalApproxPercentileNode {
6288    #[allow(deprecated)]
6289    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6290    where
6291        S: serde::Serializer,
6292    {
6293        use serde::ser::SerializeStruct;
6294        let mut len = 0;
6295        if self.base != 0. {
6296            len += 1;
6297        }
6298        if self.percentile_index != 0 {
6299            len += 1;
6300        }
6301        let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6302        if self.base != 0. {
6303            struct_ser.serialize_field("base", &self.base)?;
6304        }
6305        if self.percentile_index != 0 {
6306            struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6307        }
6308        struct_ser.end()
6309    }
6310}
6311impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6312    #[allow(deprecated)]
6313    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6314    where
6315        D: serde::Deserializer<'de>,
6316    {
6317        const FIELDS: &[&str] = &[
6318            "base",
6319            "percentile_index",
6320            "percentileIndex",
6321        ];
6322
6323        #[allow(clippy::enum_variant_names)]
6324        enum GeneratedField {
6325            Base,
6326            PercentileIndex,
6327        }
6328        impl<'de> serde::Deserialize<'de> for GeneratedField {
6329            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6330            where
6331                D: serde::Deserializer<'de>,
6332            {
6333                struct GeneratedVisitor;
6334
6335                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6336                    type Value = GeneratedField;
6337
6338                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6339                        write!(formatter, "expected one of: {:?}", &FIELDS)
6340                    }
6341
6342                    #[allow(unused_variables)]
6343                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6344                    where
6345                        E: serde::de::Error,
6346                    {
6347                        match value {
6348                            "base" => Ok(GeneratedField::Base),
6349                            "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6350                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6351                        }
6352                    }
6353                }
6354                deserializer.deserialize_identifier(GeneratedVisitor)
6355            }
6356        }
6357        struct GeneratedVisitor;
6358        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6359            type Value = LocalApproxPercentileNode;
6360
6361            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6362                formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6363            }
6364
6365            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6366                where
6367                    V: serde::de::MapAccess<'de>,
6368            {
6369                let mut base__ = None;
6370                let mut percentile_index__ = None;
6371                while let Some(k) = map_.next_key()? {
6372                    match k {
6373                        GeneratedField::Base => {
6374                            if base__.is_some() {
6375                                return Err(serde::de::Error::duplicate_field("base"));
6376                            }
6377                            base__ = 
6378                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6379                            ;
6380                        }
6381                        GeneratedField::PercentileIndex => {
6382                            if percentile_index__.is_some() {
6383                                return Err(serde::de::Error::duplicate_field("percentileIndex"));
6384                            }
6385                            percentile_index__ = 
6386                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6387                            ;
6388                        }
6389                    }
6390                }
6391                Ok(LocalApproxPercentileNode {
6392                    base: base__.unwrap_or_default(),
6393                    percentile_index: percentile_index__.unwrap_or_default(),
6394                })
6395            }
6396        }
6397        deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6398    }
6399}
6400impl serde::Serialize for LookupNode {
6401    #[allow(deprecated)]
6402    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6403    where
6404        S: serde::Serializer,
6405    {
6406        use serde::ser::SerializeStruct;
6407        let mut len = 0;
6408        if !self.arrange_key.is_empty() {
6409            len += 1;
6410        }
6411        if !self.stream_key.is_empty() {
6412            len += 1;
6413        }
6414        if self.use_current_epoch {
6415            len += 1;
6416        }
6417        if !self.column_mapping.is_empty() {
6418            len += 1;
6419        }
6420        if self.arrangement_table_info.is_some() {
6421            len += 1;
6422        }
6423        if self.arrangement_table_id.is_some() {
6424            len += 1;
6425        }
6426        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6427        if !self.arrange_key.is_empty() {
6428            struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6429        }
6430        if !self.stream_key.is_empty() {
6431            struct_ser.serialize_field("streamKey", &self.stream_key)?;
6432        }
6433        if self.use_current_epoch {
6434            struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6435        }
6436        if !self.column_mapping.is_empty() {
6437            struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6438        }
6439        if let Some(v) = self.arrangement_table_info.as_ref() {
6440            struct_ser.serialize_field("arrangementTableInfo", v)?;
6441        }
6442        if let Some(v) = self.arrangement_table_id.as_ref() {
6443            match v {
6444                lookup_node::ArrangementTableId::TableId(v) => {
6445                    struct_ser.serialize_field("tableId", v)?;
6446                }
6447                lookup_node::ArrangementTableId::IndexId(v) => {
6448                    struct_ser.serialize_field("indexId", v)?;
6449                }
6450            }
6451        }
6452        struct_ser.end()
6453    }
6454}
6455impl<'de> serde::Deserialize<'de> for LookupNode {
6456    #[allow(deprecated)]
6457    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6458    where
6459        D: serde::Deserializer<'de>,
6460    {
6461        const FIELDS: &[&str] = &[
6462            "arrange_key",
6463            "arrangeKey",
6464            "stream_key",
6465            "streamKey",
6466            "use_current_epoch",
6467            "useCurrentEpoch",
6468            "column_mapping",
6469            "columnMapping",
6470            "arrangement_table_info",
6471            "arrangementTableInfo",
6472            "table_id",
6473            "tableId",
6474            "index_id",
6475            "indexId",
6476        ];
6477
6478        #[allow(clippy::enum_variant_names)]
6479        enum GeneratedField {
6480            ArrangeKey,
6481            StreamKey,
6482            UseCurrentEpoch,
6483            ColumnMapping,
6484            ArrangementTableInfo,
6485            TableId,
6486            IndexId,
6487        }
6488        impl<'de> serde::Deserialize<'de> for GeneratedField {
6489            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6490            where
6491                D: serde::Deserializer<'de>,
6492            {
6493                struct GeneratedVisitor;
6494
6495                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6496                    type Value = GeneratedField;
6497
6498                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6499                        write!(formatter, "expected one of: {:?}", &FIELDS)
6500                    }
6501
6502                    #[allow(unused_variables)]
6503                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6504                    where
6505                        E: serde::de::Error,
6506                    {
6507                        match value {
6508                            "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6509                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6510                            "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6511                            "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6512                            "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6513                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6514                            "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6515                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6516                        }
6517                    }
6518                }
6519                deserializer.deserialize_identifier(GeneratedVisitor)
6520            }
6521        }
6522        struct GeneratedVisitor;
6523        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6524            type Value = LookupNode;
6525
6526            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6527                formatter.write_str("struct stream_plan.LookupNode")
6528            }
6529
6530            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6531                where
6532                    V: serde::de::MapAccess<'de>,
6533            {
6534                let mut arrange_key__ = None;
6535                let mut stream_key__ = None;
6536                let mut use_current_epoch__ = None;
6537                let mut column_mapping__ = None;
6538                let mut arrangement_table_info__ = None;
6539                let mut arrangement_table_id__ = None;
6540                while let Some(k) = map_.next_key()? {
6541                    match k {
6542                        GeneratedField::ArrangeKey => {
6543                            if arrange_key__.is_some() {
6544                                return Err(serde::de::Error::duplicate_field("arrangeKey"));
6545                            }
6546                            arrange_key__ = 
6547                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6548                                    .into_iter().map(|x| x.0).collect())
6549                            ;
6550                        }
6551                        GeneratedField::StreamKey => {
6552                            if stream_key__.is_some() {
6553                                return Err(serde::de::Error::duplicate_field("streamKey"));
6554                            }
6555                            stream_key__ = 
6556                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6557                                    .into_iter().map(|x| x.0).collect())
6558                            ;
6559                        }
6560                        GeneratedField::UseCurrentEpoch => {
6561                            if use_current_epoch__.is_some() {
6562                                return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6563                            }
6564                            use_current_epoch__ = Some(map_.next_value()?);
6565                        }
6566                        GeneratedField::ColumnMapping => {
6567                            if column_mapping__.is_some() {
6568                                return Err(serde::de::Error::duplicate_field("columnMapping"));
6569                            }
6570                            column_mapping__ = 
6571                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6572                                    .into_iter().map(|x| x.0).collect())
6573                            ;
6574                        }
6575                        GeneratedField::ArrangementTableInfo => {
6576                            if arrangement_table_info__.is_some() {
6577                                return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6578                            }
6579                            arrangement_table_info__ = map_.next_value()?;
6580                        }
6581                        GeneratedField::TableId => {
6582                            if arrangement_table_id__.is_some() {
6583                                return Err(serde::de::Error::duplicate_field("tableId"));
6584                            }
6585                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6586                        }
6587                        GeneratedField::IndexId => {
6588                            if arrangement_table_id__.is_some() {
6589                                return Err(serde::de::Error::duplicate_field("indexId"));
6590                            }
6591                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6592                        }
6593                    }
6594                }
6595                Ok(LookupNode {
6596                    arrange_key: arrange_key__.unwrap_or_default(),
6597                    stream_key: stream_key__.unwrap_or_default(),
6598                    use_current_epoch: use_current_epoch__.unwrap_or_default(),
6599                    column_mapping: column_mapping__.unwrap_or_default(),
6600                    arrangement_table_info: arrangement_table_info__,
6601                    arrangement_table_id: arrangement_table_id__,
6602                })
6603            }
6604        }
6605        deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6606    }
6607}
6608impl serde::Serialize for LookupUnionNode {
6609    #[allow(deprecated)]
6610    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6611    where
6612        S: serde::Serializer,
6613    {
6614        use serde::ser::SerializeStruct;
6615        let mut len = 0;
6616        if !self.order.is_empty() {
6617            len += 1;
6618        }
6619        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6620        if !self.order.is_empty() {
6621            struct_ser.serialize_field("order", &self.order)?;
6622        }
6623        struct_ser.end()
6624    }
6625}
6626impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6627    #[allow(deprecated)]
6628    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6629    where
6630        D: serde::Deserializer<'de>,
6631    {
6632        const FIELDS: &[&str] = &[
6633            "order",
6634        ];
6635
6636        #[allow(clippy::enum_variant_names)]
6637        enum GeneratedField {
6638            Order,
6639        }
6640        impl<'de> serde::Deserialize<'de> for GeneratedField {
6641            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6642            where
6643                D: serde::Deserializer<'de>,
6644            {
6645                struct GeneratedVisitor;
6646
6647                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6648                    type Value = GeneratedField;
6649
6650                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6651                        write!(formatter, "expected one of: {:?}", &FIELDS)
6652                    }
6653
6654                    #[allow(unused_variables)]
6655                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6656                    where
6657                        E: serde::de::Error,
6658                    {
6659                        match value {
6660                            "order" => Ok(GeneratedField::Order),
6661                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6662                        }
6663                    }
6664                }
6665                deserializer.deserialize_identifier(GeneratedVisitor)
6666            }
6667        }
6668        struct GeneratedVisitor;
6669        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6670            type Value = LookupUnionNode;
6671
6672            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6673                formatter.write_str("struct stream_plan.LookupUnionNode")
6674            }
6675
6676            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6677                where
6678                    V: serde::de::MapAccess<'de>,
6679            {
6680                let mut order__ = None;
6681                while let Some(k) = map_.next_key()? {
6682                    match k {
6683                        GeneratedField::Order => {
6684                            if order__.is_some() {
6685                                return Err(serde::de::Error::duplicate_field("order"));
6686                            }
6687                            order__ = 
6688                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6689                                    .into_iter().map(|x| x.0).collect())
6690                            ;
6691                        }
6692                    }
6693                }
6694                Ok(LookupUnionNode {
6695                    order: order__.unwrap_or_default(),
6696                })
6697            }
6698        }
6699        deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6700    }
6701}
6702impl serde::Serialize for MaterializeNode {
6703    #[allow(deprecated)]
6704    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6705    where
6706        S: serde::Serializer,
6707    {
6708        use serde::ser::SerializeStruct;
6709        let mut len = 0;
6710        if self.table_id != 0 {
6711            len += 1;
6712        }
6713        if !self.column_orders.is_empty() {
6714            len += 1;
6715        }
6716        if self.table.is_some() {
6717            len += 1;
6718        }
6719        if self.staging_table.is_some() {
6720            len += 1;
6721        }
6722        if self.refresh_progress_table.is_some() {
6723            len += 1;
6724        }
6725        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6726        if self.table_id != 0 {
6727            struct_ser.serialize_field("tableId", &self.table_id)?;
6728        }
6729        if !self.column_orders.is_empty() {
6730            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6731        }
6732        if let Some(v) = self.table.as_ref() {
6733            struct_ser.serialize_field("table", v)?;
6734        }
6735        if let Some(v) = self.staging_table.as_ref() {
6736            struct_ser.serialize_field("stagingTable", v)?;
6737        }
6738        if let Some(v) = self.refresh_progress_table.as_ref() {
6739            struct_ser.serialize_field("refreshProgressTable", v)?;
6740        }
6741        struct_ser.end()
6742    }
6743}
6744impl<'de> serde::Deserialize<'de> for MaterializeNode {
6745    #[allow(deprecated)]
6746    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6747    where
6748        D: serde::Deserializer<'de>,
6749    {
6750        const FIELDS: &[&str] = &[
6751            "table_id",
6752            "tableId",
6753            "column_orders",
6754            "columnOrders",
6755            "table",
6756            "staging_table",
6757            "stagingTable",
6758            "refresh_progress_table",
6759            "refreshProgressTable",
6760        ];
6761
6762        #[allow(clippy::enum_variant_names)]
6763        enum GeneratedField {
6764            TableId,
6765            ColumnOrders,
6766            Table,
6767            StagingTable,
6768            RefreshProgressTable,
6769        }
6770        impl<'de> serde::Deserialize<'de> for GeneratedField {
6771            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6772            where
6773                D: serde::Deserializer<'de>,
6774            {
6775                struct GeneratedVisitor;
6776
6777                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6778                    type Value = GeneratedField;
6779
6780                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6781                        write!(formatter, "expected one of: {:?}", &FIELDS)
6782                    }
6783
6784                    #[allow(unused_variables)]
6785                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6786                    where
6787                        E: serde::de::Error,
6788                    {
6789                        match value {
6790                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6791                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6792                            "table" => Ok(GeneratedField::Table),
6793                            "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
6794                            "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
6795                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6796                        }
6797                    }
6798                }
6799                deserializer.deserialize_identifier(GeneratedVisitor)
6800            }
6801        }
6802        struct GeneratedVisitor;
6803        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6804            type Value = MaterializeNode;
6805
6806            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6807                formatter.write_str("struct stream_plan.MaterializeNode")
6808            }
6809
6810            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6811                where
6812                    V: serde::de::MapAccess<'de>,
6813            {
6814                let mut table_id__ = None;
6815                let mut column_orders__ = None;
6816                let mut table__ = None;
6817                let mut staging_table__ = None;
6818                let mut refresh_progress_table__ = None;
6819                while let Some(k) = map_.next_key()? {
6820                    match k {
6821                        GeneratedField::TableId => {
6822                            if table_id__.is_some() {
6823                                return Err(serde::de::Error::duplicate_field("tableId"));
6824                            }
6825                            table_id__ = 
6826                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6827                            ;
6828                        }
6829                        GeneratedField::ColumnOrders => {
6830                            if column_orders__.is_some() {
6831                                return Err(serde::de::Error::duplicate_field("columnOrders"));
6832                            }
6833                            column_orders__ = Some(map_.next_value()?);
6834                        }
6835                        GeneratedField::Table => {
6836                            if table__.is_some() {
6837                                return Err(serde::de::Error::duplicate_field("table"));
6838                            }
6839                            table__ = map_.next_value()?;
6840                        }
6841                        GeneratedField::StagingTable => {
6842                            if staging_table__.is_some() {
6843                                return Err(serde::de::Error::duplicate_field("stagingTable"));
6844                            }
6845                            staging_table__ = map_.next_value()?;
6846                        }
6847                        GeneratedField::RefreshProgressTable => {
6848                            if refresh_progress_table__.is_some() {
6849                                return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
6850                            }
6851                            refresh_progress_table__ = map_.next_value()?;
6852                        }
6853                    }
6854                }
6855                Ok(MaterializeNode {
6856                    table_id: table_id__.unwrap_or_default(),
6857                    column_orders: column_orders__.unwrap_or_default(),
6858                    table: table__,
6859                    staging_table: staging_table__,
6860                    refresh_progress_table: refresh_progress_table__,
6861                })
6862            }
6863        }
6864        deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6865    }
6866}
6867impl serde::Serialize for MaterializedExprsNode {
6868    #[allow(deprecated)]
6869    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6870    where
6871        S: serde::Serializer,
6872    {
6873        use serde::ser::SerializeStruct;
6874        let mut len = 0;
6875        if !self.exprs.is_empty() {
6876            len += 1;
6877        }
6878        if self.state_table.is_some() {
6879            len += 1;
6880        }
6881        if self.state_clean_col_idx.is_some() {
6882            len += 1;
6883        }
6884        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6885        if !self.exprs.is_empty() {
6886            struct_ser.serialize_field("exprs", &self.exprs)?;
6887        }
6888        if let Some(v) = self.state_table.as_ref() {
6889            struct_ser.serialize_field("stateTable", v)?;
6890        }
6891        if let Some(v) = self.state_clean_col_idx.as_ref() {
6892            struct_ser.serialize_field("stateCleanColIdx", v)?;
6893        }
6894        struct_ser.end()
6895    }
6896}
6897impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6898    #[allow(deprecated)]
6899    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6900    where
6901        D: serde::Deserializer<'de>,
6902    {
6903        const FIELDS: &[&str] = &[
6904            "exprs",
6905            "state_table",
6906            "stateTable",
6907            "state_clean_col_idx",
6908            "stateCleanColIdx",
6909        ];
6910
6911        #[allow(clippy::enum_variant_names)]
6912        enum GeneratedField {
6913            Exprs,
6914            StateTable,
6915            StateCleanColIdx,
6916        }
6917        impl<'de> serde::Deserialize<'de> for GeneratedField {
6918            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6919            where
6920                D: serde::Deserializer<'de>,
6921            {
6922                struct GeneratedVisitor;
6923
6924                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6925                    type Value = GeneratedField;
6926
6927                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6928                        write!(formatter, "expected one of: {:?}", &FIELDS)
6929                    }
6930
6931                    #[allow(unused_variables)]
6932                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6933                    where
6934                        E: serde::de::Error,
6935                    {
6936                        match value {
6937                            "exprs" => Ok(GeneratedField::Exprs),
6938                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6939                            "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6940                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6941                        }
6942                    }
6943                }
6944                deserializer.deserialize_identifier(GeneratedVisitor)
6945            }
6946        }
6947        struct GeneratedVisitor;
6948        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6949            type Value = MaterializedExprsNode;
6950
6951            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6952                formatter.write_str("struct stream_plan.MaterializedExprsNode")
6953            }
6954
6955            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6956                where
6957                    V: serde::de::MapAccess<'de>,
6958            {
6959                let mut exprs__ = None;
6960                let mut state_table__ = None;
6961                let mut state_clean_col_idx__ = None;
6962                while let Some(k) = map_.next_key()? {
6963                    match k {
6964                        GeneratedField::Exprs => {
6965                            if exprs__.is_some() {
6966                                return Err(serde::de::Error::duplicate_field("exprs"));
6967                            }
6968                            exprs__ = Some(map_.next_value()?);
6969                        }
6970                        GeneratedField::StateTable => {
6971                            if state_table__.is_some() {
6972                                return Err(serde::de::Error::duplicate_field("stateTable"));
6973                            }
6974                            state_table__ = map_.next_value()?;
6975                        }
6976                        GeneratedField::StateCleanColIdx => {
6977                            if state_clean_col_idx__.is_some() {
6978                                return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6979                            }
6980                            state_clean_col_idx__ = 
6981                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6982                            ;
6983                        }
6984                    }
6985                }
6986                Ok(MaterializedExprsNode {
6987                    exprs: exprs__.unwrap_or_default(),
6988                    state_table: state_table__,
6989                    state_clean_col_idx: state_clean_col_idx__,
6990                })
6991            }
6992        }
6993        deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6994    }
6995}
6996impl serde::Serialize for MergeNode {
6997    #[allow(deprecated)]
6998    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6999    where
7000        S: serde::Serializer,
7001    {
7002        use serde::ser::SerializeStruct;
7003        let mut len = 0;
7004        if !self.upstream_actor_id.is_empty() {
7005            len += 1;
7006        }
7007        if self.upstream_fragment_id != 0 {
7008            len += 1;
7009        }
7010        if self.upstream_dispatcher_type != 0 {
7011            len += 1;
7012        }
7013        if !self.fields.is_empty() {
7014            len += 1;
7015        }
7016        let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7017        if !self.upstream_actor_id.is_empty() {
7018            struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7019        }
7020        if self.upstream_fragment_id != 0 {
7021            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7022        }
7023        if self.upstream_dispatcher_type != 0 {
7024            let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7025                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7026            struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7027        }
7028        if !self.fields.is_empty() {
7029            struct_ser.serialize_field("fields", &self.fields)?;
7030        }
7031        struct_ser.end()
7032    }
7033}
7034impl<'de> serde::Deserialize<'de> for MergeNode {
7035    #[allow(deprecated)]
7036    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7037    where
7038        D: serde::Deserializer<'de>,
7039    {
7040        const FIELDS: &[&str] = &[
7041            "upstream_actor_id",
7042            "upstreamActorId",
7043            "upstream_fragment_id",
7044            "upstreamFragmentId",
7045            "upstream_dispatcher_type",
7046            "upstreamDispatcherType",
7047            "fields",
7048        ];
7049
7050        #[allow(clippy::enum_variant_names)]
7051        enum GeneratedField {
7052            UpstreamActorId,
7053            UpstreamFragmentId,
7054            UpstreamDispatcherType,
7055            Fields,
7056        }
7057        impl<'de> serde::Deserialize<'de> for GeneratedField {
7058            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7059            where
7060                D: serde::Deserializer<'de>,
7061            {
7062                struct GeneratedVisitor;
7063
7064                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7065                    type Value = GeneratedField;
7066
7067                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7068                        write!(formatter, "expected one of: {:?}", &FIELDS)
7069                    }
7070
7071                    #[allow(unused_variables)]
7072                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7073                    where
7074                        E: serde::de::Error,
7075                    {
7076                        match value {
7077                            "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7078                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7079                            "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7080                            "fields" => Ok(GeneratedField::Fields),
7081                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7082                        }
7083                    }
7084                }
7085                deserializer.deserialize_identifier(GeneratedVisitor)
7086            }
7087        }
7088        struct GeneratedVisitor;
7089        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7090            type Value = MergeNode;
7091
7092            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7093                formatter.write_str("struct stream_plan.MergeNode")
7094            }
7095
7096            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7097                where
7098                    V: serde::de::MapAccess<'de>,
7099            {
7100                let mut upstream_actor_id__ = None;
7101                let mut upstream_fragment_id__ = None;
7102                let mut upstream_dispatcher_type__ = None;
7103                let mut fields__ = None;
7104                while let Some(k) = map_.next_key()? {
7105                    match k {
7106                        GeneratedField::UpstreamActorId => {
7107                            if upstream_actor_id__.is_some() {
7108                                return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7109                            }
7110                            upstream_actor_id__ = 
7111                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7112                                    .into_iter().map(|x| x.0).collect())
7113                            ;
7114                        }
7115                        GeneratedField::UpstreamFragmentId => {
7116                            if upstream_fragment_id__.is_some() {
7117                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7118                            }
7119                            upstream_fragment_id__ = 
7120                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7121                            ;
7122                        }
7123                        GeneratedField::UpstreamDispatcherType => {
7124                            if upstream_dispatcher_type__.is_some() {
7125                                return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7126                            }
7127                            upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7128                        }
7129                        GeneratedField::Fields => {
7130                            if fields__.is_some() {
7131                                return Err(serde::de::Error::duplicate_field("fields"));
7132                            }
7133                            fields__ = Some(map_.next_value()?);
7134                        }
7135                    }
7136                }
7137                Ok(MergeNode {
7138                    upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7139                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7140                    upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7141                    fields: fields__.unwrap_or_default(),
7142                })
7143            }
7144        }
7145        deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7146    }
7147}
7148impl serde::Serialize for NoOpNode {
7149    #[allow(deprecated)]
7150    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7151    where
7152        S: serde::Serializer,
7153    {
7154        use serde::ser::SerializeStruct;
7155        let len = 0;
7156        let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7157        struct_ser.end()
7158    }
7159}
7160impl<'de> serde::Deserialize<'de> for NoOpNode {
7161    #[allow(deprecated)]
7162    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7163    where
7164        D: serde::Deserializer<'de>,
7165    {
7166        const FIELDS: &[&str] = &[
7167        ];
7168
7169        #[allow(clippy::enum_variant_names)]
7170        enum GeneratedField {
7171        }
7172        impl<'de> serde::Deserialize<'de> for GeneratedField {
7173            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7174            where
7175                D: serde::Deserializer<'de>,
7176            {
7177                struct GeneratedVisitor;
7178
7179                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7180                    type Value = GeneratedField;
7181
7182                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7183                        write!(formatter, "expected one of: {:?}", &FIELDS)
7184                    }
7185
7186                    #[allow(unused_variables)]
7187                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7188                    where
7189                        E: serde::de::Error,
7190                    {
7191                            Err(serde::de::Error::unknown_field(value, FIELDS))
7192                    }
7193                }
7194                deserializer.deserialize_identifier(GeneratedVisitor)
7195            }
7196        }
7197        struct GeneratedVisitor;
7198        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7199            type Value = NoOpNode;
7200
7201            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7202                formatter.write_str("struct stream_plan.NoOpNode")
7203            }
7204
7205            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7206                where
7207                    V: serde::de::MapAccess<'de>,
7208            {
7209                while map_.next_key::<GeneratedField>()?.is_some() {
7210                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7211                }
7212                Ok(NoOpNode {
7213                })
7214            }
7215        }
7216        deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7217    }
7218}
7219impl serde::Serialize for NowModeGenerateSeries {
7220    #[allow(deprecated)]
7221    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7222    where
7223        S: serde::Serializer,
7224    {
7225        use serde::ser::SerializeStruct;
7226        let mut len = 0;
7227        if self.start_timestamp.is_some() {
7228            len += 1;
7229        }
7230        if self.interval.is_some() {
7231            len += 1;
7232        }
7233        let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7234        if let Some(v) = self.start_timestamp.as_ref() {
7235            struct_ser.serialize_field("startTimestamp", v)?;
7236        }
7237        if let Some(v) = self.interval.as_ref() {
7238            struct_ser.serialize_field("interval", v)?;
7239        }
7240        struct_ser.end()
7241    }
7242}
7243impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7244    #[allow(deprecated)]
7245    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7246    where
7247        D: serde::Deserializer<'de>,
7248    {
7249        const FIELDS: &[&str] = &[
7250            "start_timestamp",
7251            "startTimestamp",
7252            "interval",
7253        ];
7254
7255        #[allow(clippy::enum_variant_names)]
7256        enum GeneratedField {
7257            StartTimestamp,
7258            Interval,
7259        }
7260        impl<'de> serde::Deserialize<'de> for GeneratedField {
7261            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7262            where
7263                D: serde::Deserializer<'de>,
7264            {
7265                struct GeneratedVisitor;
7266
7267                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7268                    type Value = GeneratedField;
7269
7270                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7271                        write!(formatter, "expected one of: {:?}", &FIELDS)
7272                    }
7273
7274                    #[allow(unused_variables)]
7275                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7276                    where
7277                        E: serde::de::Error,
7278                    {
7279                        match value {
7280                            "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7281                            "interval" => Ok(GeneratedField::Interval),
7282                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7283                        }
7284                    }
7285                }
7286                deserializer.deserialize_identifier(GeneratedVisitor)
7287            }
7288        }
7289        struct GeneratedVisitor;
7290        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7291            type Value = NowModeGenerateSeries;
7292
7293            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7294                formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7295            }
7296
7297            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7298                where
7299                    V: serde::de::MapAccess<'de>,
7300            {
7301                let mut start_timestamp__ = None;
7302                let mut interval__ = None;
7303                while let Some(k) = map_.next_key()? {
7304                    match k {
7305                        GeneratedField::StartTimestamp => {
7306                            if start_timestamp__.is_some() {
7307                                return Err(serde::de::Error::duplicate_field("startTimestamp"));
7308                            }
7309                            start_timestamp__ = map_.next_value()?;
7310                        }
7311                        GeneratedField::Interval => {
7312                            if interval__.is_some() {
7313                                return Err(serde::de::Error::duplicate_field("interval"));
7314                            }
7315                            interval__ = map_.next_value()?;
7316                        }
7317                    }
7318                }
7319                Ok(NowModeGenerateSeries {
7320                    start_timestamp: start_timestamp__,
7321                    interval: interval__,
7322                })
7323            }
7324        }
7325        deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7326    }
7327}
7328impl serde::Serialize for NowModeUpdateCurrent {
7329    #[allow(deprecated)]
7330    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7331    where
7332        S: serde::Serializer,
7333    {
7334        use serde::ser::SerializeStruct;
7335        let len = 0;
7336        let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7337        struct_ser.end()
7338    }
7339}
7340impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7341    #[allow(deprecated)]
7342    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7343    where
7344        D: serde::Deserializer<'de>,
7345    {
7346        const FIELDS: &[&str] = &[
7347        ];
7348
7349        #[allow(clippy::enum_variant_names)]
7350        enum GeneratedField {
7351        }
7352        impl<'de> serde::Deserialize<'de> for GeneratedField {
7353            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7354            where
7355                D: serde::Deserializer<'de>,
7356            {
7357                struct GeneratedVisitor;
7358
7359                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7360                    type Value = GeneratedField;
7361
7362                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7363                        write!(formatter, "expected one of: {:?}", &FIELDS)
7364                    }
7365
7366                    #[allow(unused_variables)]
7367                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7368                    where
7369                        E: serde::de::Error,
7370                    {
7371                            Err(serde::de::Error::unknown_field(value, FIELDS))
7372                    }
7373                }
7374                deserializer.deserialize_identifier(GeneratedVisitor)
7375            }
7376        }
7377        struct GeneratedVisitor;
7378        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7379            type Value = NowModeUpdateCurrent;
7380
7381            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7382                formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7383            }
7384
7385            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7386                where
7387                    V: serde::de::MapAccess<'de>,
7388            {
7389                while map_.next_key::<GeneratedField>()?.is_some() {
7390                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7391                }
7392                Ok(NowModeUpdateCurrent {
7393                })
7394            }
7395        }
7396        deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7397    }
7398}
7399impl serde::Serialize for NowNode {
7400    #[allow(deprecated)]
7401    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7402    where
7403        S: serde::Serializer,
7404    {
7405        use serde::ser::SerializeStruct;
7406        let mut len = 0;
7407        if self.state_table.is_some() {
7408            len += 1;
7409        }
7410        if self.mode.is_some() {
7411            len += 1;
7412        }
7413        let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7414        if let Some(v) = self.state_table.as_ref() {
7415            struct_ser.serialize_field("stateTable", v)?;
7416        }
7417        if let Some(v) = self.mode.as_ref() {
7418            match v {
7419                now_node::Mode::UpdateCurrent(v) => {
7420                    struct_ser.serialize_field("updateCurrent", v)?;
7421                }
7422                now_node::Mode::GenerateSeries(v) => {
7423                    struct_ser.serialize_field("generateSeries", v)?;
7424                }
7425            }
7426        }
7427        struct_ser.end()
7428    }
7429}
7430impl<'de> serde::Deserialize<'de> for NowNode {
7431    #[allow(deprecated)]
7432    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7433    where
7434        D: serde::Deserializer<'de>,
7435    {
7436        const FIELDS: &[&str] = &[
7437            "state_table",
7438            "stateTable",
7439            "update_current",
7440            "updateCurrent",
7441            "generate_series",
7442            "generateSeries",
7443        ];
7444
7445        #[allow(clippy::enum_variant_names)]
7446        enum GeneratedField {
7447            StateTable,
7448            UpdateCurrent,
7449            GenerateSeries,
7450        }
7451        impl<'de> serde::Deserialize<'de> for GeneratedField {
7452            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7453            where
7454                D: serde::Deserializer<'de>,
7455            {
7456                struct GeneratedVisitor;
7457
7458                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7459                    type Value = GeneratedField;
7460
7461                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7462                        write!(formatter, "expected one of: {:?}", &FIELDS)
7463                    }
7464
7465                    #[allow(unused_variables)]
7466                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7467                    where
7468                        E: serde::de::Error,
7469                    {
7470                        match value {
7471                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7472                            "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7473                            "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7474                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7475                        }
7476                    }
7477                }
7478                deserializer.deserialize_identifier(GeneratedVisitor)
7479            }
7480        }
7481        struct GeneratedVisitor;
7482        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7483            type Value = NowNode;
7484
7485            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7486                formatter.write_str("struct stream_plan.NowNode")
7487            }
7488
7489            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7490                where
7491                    V: serde::de::MapAccess<'de>,
7492            {
7493                let mut state_table__ = None;
7494                let mut mode__ = None;
7495                while let Some(k) = map_.next_key()? {
7496                    match k {
7497                        GeneratedField::StateTable => {
7498                            if state_table__.is_some() {
7499                                return Err(serde::de::Error::duplicate_field("stateTable"));
7500                            }
7501                            state_table__ = map_.next_value()?;
7502                        }
7503                        GeneratedField::UpdateCurrent => {
7504                            if mode__.is_some() {
7505                                return Err(serde::de::Error::duplicate_field("updateCurrent"));
7506                            }
7507                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7508;
7509                        }
7510                        GeneratedField::GenerateSeries => {
7511                            if mode__.is_some() {
7512                                return Err(serde::de::Error::duplicate_field("generateSeries"));
7513                            }
7514                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7515;
7516                        }
7517                    }
7518                }
7519                Ok(NowNode {
7520                    state_table: state_table__,
7521                    mode: mode__,
7522                })
7523            }
7524        }
7525        deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7526    }
7527}
7528impl serde::Serialize for OverWindowCachePolicy {
7529    #[allow(deprecated)]
7530    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7531    where
7532        S: serde::Serializer,
7533    {
7534        let variant = match self {
7535            Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7536            Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7537            Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7538            Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7539            Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7540        };
7541        serializer.serialize_str(variant)
7542    }
7543}
7544impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7545    #[allow(deprecated)]
7546    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7547    where
7548        D: serde::Deserializer<'de>,
7549    {
7550        const FIELDS: &[&str] = &[
7551            "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7552            "OVER_WINDOW_CACHE_POLICY_FULL",
7553            "OVER_WINDOW_CACHE_POLICY_RECENT",
7554            "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7555            "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7556        ];
7557
7558        struct GeneratedVisitor;
7559
7560        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7561            type Value = OverWindowCachePolicy;
7562
7563            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7564                write!(formatter, "expected one of: {:?}", &FIELDS)
7565            }
7566
7567            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7568            where
7569                E: serde::de::Error,
7570            {
7571                i32::try_from(v)
7572                    .ok()
7573                    .and_then(|x| x.try_into().ok())
7574                    .ok_or_else(|| {
7575                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7576                    })
7577            }
7578
7579            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7580            where
7581                E: serde::de::Error,
7582            {
7583                i32::try_from(v)
7584                    .ok()
7585                    .and_then(|x| x.try_into().ok())
7586                    .ok_or_else(|| {
7587                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7588                    })
7589            }
7590
7591            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7592            where
7593                E: serde::de::Error,
7594            {
7595                match value {
7596                    "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7597                    "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7598                    "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7599                    "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7600                    "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7601                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7602                }
7603            }
7604        }
7605        deserializer.deserialize_any(GeneratedVisitor)
7606    }
7607}
7608impl serde::Serialize for OverWindowNode {
7609    #[allow(deprecated)]
7610    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7611    where
7612        S: serde::Serializer,
7613    {
7614        use serde::ser::SerializeStruct;
7615        let mut len = 0;
7616        if !self.calls.is_empty() {
7617            len += 1;
7618        }
7619        if !self.partition_by.is_empty() {
7620            len += 1;
7621        }
7622        if !self.order_by.is_empty() {
7623            len += 1;
7624        }
7625        if self.state_table.is_some() {
7626            len += 1;
7627        }
7628        if self.cache_policy != 0 {
7629            len += 1;
7630        }
7631        let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7632        if !self.calls.is_empty() {
7633            struct_ser.serialize_field("calls", &self.calls)?;
7634        }
7635        if !self.partition_by.is_empty() {
7636            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7637        }
7638        if !self.order_by.is_empty() {
7639            struct_ser.serialize_field("orderBy", &self.order_by)?;
7640        }
7641        if let Some(v) = self.state_table.as_ref() {
7642            struct_ser.serialize_field("stateTable", v)?;
7643        }
7644        if self.cache_policy != 0 {
7645            let v = OverWindowCachePolicy::try_from(self.cache_policy)
7646                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7647            struct_ser.serialize_field("cachePolicy", &v)?;
7648        }
7649        struct_ser.end()
7650    }
7651}
7652impl<'de> serde::Deserialize<'de> for OverWindowNode {
7653    #[allow(deprecated)]
7654    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7655    where
7656        D: serde::Deserializer<'de>,
7657    {
7658        const FIELDS: &[&str] = &[
7659            "calls",
7660            "partition_by",
7661            "partitionBy",
7662            "order_by",
7663            "orderBy",
7664            "state_table",
7665            "stateTable",
7666            "cache_policy",
7667            "cachePolicy",
7668        ];
7669
7670        #[allow(clippy::enum_variant_names)]
7671        enum GeneratedField {
7672            Calls,
7673            PartitionBy,
7674            OrderBy,
7675            StateTable,
7676            CachePolicy,
7677        }
7678        impl<'de> serde::Deserialize<'de> for GeneratedField {
7679            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7680            where
7681                D: serde::Deserializer<'de>,
7682            {
7683                struct GeneratedVisitor;
7684
7685                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7686                    type Value = GeneratedField;
7687
7688                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7689                        write!(formatter, "expected one of: {:?}", &FIELDS)
7690                    }
7691
7692                    #[allow(unused_variables)]
7693                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7694                    where
7695                        E: serde::de::Error,
7696                    {
7697                        match value {
7698                            "calls" => Ok(GeneratedField::Calls),
7699                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7700                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7701                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7702                            "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7703                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7704                        }
7705                    }
7706                }
7707                deserializer.deserialize_identifier(GeneratedVisitor)
7708            }
7709        }
7710        struct GeneratedVisitor;
7711        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7712            type Value = OverWindowNode;
7713
7714            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7715                formatter.write_str("struct stream_plan.OverWindowNode")
7716            }
7717
7718            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7719                where
7720                    V: serde::de::MapAccess<'de>,
7721            {
7722                let mut calls__ = None;
7723                let mut partition_by__ = None;
7724                let mut order_by__ = None;
7725                let mut state_table__ = None;
7726                let mut cache_policy__ = None;
7727                while let Some(k) = map_.next_key()? {
7728                    match k {
7729                        GeneratedField::Calls => {
7730                            if calls__.is_some() {
7731                                return Err(serde::de::Error::duplicate_field("calls"));
7732                            }
7733                            calls__ = Some(map_.next_value()?);
7734                        }
7735                        GeneratedField::PartitionBy => {
7736                            if partition_by__.is_some() {
7737                                return Err(serde::de::Error::duplicate_field("partitionBy"));
7738                            }
7739                            partition_by__ = 
7740                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7741                                    .into_iter().map(|x| x.0).collect())
7742                            ;
7743                        }
7744                        GeneratedField::OrderBy => {
7745                            if order_by__.is_some() {
7746                                return Err(serde::de::Error::duplicate_field("orderBy"));
7747                            }
7748                            order_by__ = Some(map_.next_value()?);
7749                        }
7750                        GeneratedField::StateTable => {
7751                            if state_table__.is_some() {
7752                                return Err(serde::de::Error::duplicate_field("stateTable"));
7753                            }
7754                            state_table__ = map_.next_value()?;
7755                        }
7756                        GeneratedField::CachePolicy => {
7757                            if cache_policy__.is_some() {
7758                                return Err(serde::de::Error::duplicate_field("cachePolicy"));
7759                            }
7760                            cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7761                        }
7762                    }
7763                }
7764                Ok(OverWindowNode {
7765                    calls: calls__.unwrap_or_default(),
7766                    partition_by: partition_by__.unwrap_or_default(),
7767                    order_by: order_by__.unwrap_or_default(),
7768                    state_table: state_table__,
7769                    cache_policy: cache_policy__.unwrap_or_default(),
7770                })
7771            }
7772        }
7773        deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7774    }
7775}
7776impl serde::Serialize for PauseMutation {
7777    #[allow(deprecated)]
7778    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7779    where
7780        S: serde::Serializer,
7781    {
7782        use serde::ser::SerializeStruct;
7783        let len = 0;
7784        let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7785        struct_ser.end()
7786    }
7787}
7788impl<'de> serde::Deserialize<'de> for PauseMutation {
7789    #[allow(deprecated)]
7790    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7791    where
7792        D: serde::Deserializer<'de>,
7793    {
7794        const FIELDS: &[&str] = &[
7795        ];
7796
7797        #[allow(clippy::enum_variant_names)]
7798        enum GeneratedField {
7799        }
7800        impl<'de> serde::Deserialize<'de> for GeneratedField {
7801            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7802            where
7803                D: serde::Deserializer<'de>,
7804            {
7805                struct GeneratedVisitor;
7806
7807                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7808                    type Value = GeneratedField;
7809
7810                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7811                        write!(formatter, "expected one of: {:?}", &FIELDS)
7812                    }
7813
7814                    #[allow(unused_variables)]
7815                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7816                    where
7817                        E: serde::de::Error,
7818                    {
7819                            Err(serde::de::Error::unknown_field(value, FIELDS))
7820                    }
7821                }
7822                deserializer.deserialize_identifier(GeneratedVisitor)
7823            }
7824        }
7825        struct GeneratedVisitor;
7826        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7827            type Value = PauseMutation;
7828
7829            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7830                formatter.write_str("struct stream_plan.PauseMutation")
7831            }
7832
7833            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7834                where
7835                    V: serde::de::MapAccess<'de>,
7836            {
7837                while map_.next_key::<GeneratedField>()?.is_some() {
7838                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7839                }
7840                Ok(PauseMutation {
7841                })
7842            }
7843        }
7844        deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7845    }
7846}
7847impl serde::Serialize for ProjectNode {
7848    #[allow(deprecated)]
7849    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7850    where
7851        S: serde::Serializer,
7852    {
7853        use serde::ser::SerializeStruct;
7854        let mut len = 0;
7855        if !self.select_list.is_empty() {
7856            len += 1;
7857        }
7858        if !self.watermark_input_cols.is_empty() {
7859            len += 1;
7860        }
7861        if !self.watermark_output_cols.is_empty() {
7862            len += 1;
7863        }
7864        if !self.nondecreasing_exprs.is_empty() {
7865            len += 1;
7866        }
7867        if self.noop_update_hint {
7868            len += 1;
7869        }
7870        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7871        if !self.select_list.is_empty() {
7872            struct_ser.serialize_field("selectList", &self.select_list)?;
7873        }
7874        if !self.watermark_input_cols.is_empty() {
7875            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7876        }
7877        if !self.watermark_output_cols.is_empty() {
7878            struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7879        }
7880        if !self.nondecreasing_exprs.is_empty() {
7881            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7882        }
7883        if self.noop_update_hint {
7884            struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7885        }
7886        struct_ser.end()
7887    }
7888}
7889impl<'de> serde::Deserialize<'de> for ProjectNode {
7890    #[allow(deprecated)]
7891    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7892    where
7893        D: serde::Deserializer<'de>,
7894    {
7895        const FIELDS: &[&str] = &[
7896            "select_list",
7897            "selectList",
7898            "watermark_input_cols",
7899            "watermarkInputCols",
7900            "watermark_output_cols",
7901            "watermarkOutputCols",
7902            "nondecreasing_exprs",
7903            "nondecreasingExprs",
7904            "noop_update_hint",
7905            "noopUpdateHint",
7906        ];
7907
7908        #[allow(clippy::enum_variant_names)]
7909        enum GeneratedField {
7910            SelectList,
7911            WatermarkInputCols,
7912            WatermarkOutputCols,
7913            NondecreasingExprs,
7914            NoopUpdateHint,
7915        }
7916        impl<'de> serde::Deserialize<'de> for GeneratedField {
7917            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7918            where
7919                D: serde::Deserializer<'de>,
7920            {
7921                struct GeneratedVisitor;
7922
7923                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7924                    type Value = GeneratedField;
7925
7926                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7927                        write!(formatter, "expected one of: {:?}", &FIELDS)
7928                    }
7929
7930                    #[allow(unused_variables)]
7931                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7932                    where
7933                        E: serde::de::Error,
7934                    {
7935                        match value {
7936                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7937                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7938                            "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7939                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7940                            "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7941                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7942                        }
7943                    }
7944                }
7945                deserializer.deserialize_identifier(GeneratedVisitor)
7946            }
7947        }
7948        struct GeneratedVisitor;
7949        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7950            type Value = ProjectNode;
7951
7952            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7953                formatter.write_str("struct stream_plan.ProjectNode")
7954            }
7955
7956            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7957                where
7958                    V: serde::de::MapAccess<'de>,
7959            {
7960                let mut select_list__ = None;
7961                let mut watermark_input_cols__ = None;
7962                let mut watermark_output_cols__ = None;
7963                let mut nondecreasing_exprs__ = None;
7964                let mut noop_update_hint__ = None;
7965                while let Some(k) = map_.next_key()? {
7966                    match k {
7967                        GeneratedField::SelectList => {
7968                            if select_list__.is_some() {
7969                                return Err(serde::de::Error::duplicate_field("selectList"));
7970                            }
7971                            select_list__ = Some(map_.next_value()?);
7972                        }
7973                        GeneratedField::WatermarkInputCols => {
7974                            if watermark_input_cols__.is_some() {
7975                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7976                            }
7977                            watermark_input_cols__ = 
7978                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7979                                    .into_iter().map(|x| x.0).collect())
7980                            ;
7981                        }
7982                        GeneratedField::WatermarkOutputCols => {
7983                            if watermark_output_cols__.is_some() {
7984                                return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7985                            }
7986                            watermark_output_cols__ = 
7987                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7988                                    .into_iter().map(|x| x.0).collect())
7989                            ;
7990                        }
7991                        GeneratedField::NondecreasingExprs => {
7992                            if nondecreasing_exprs__.is_some() {
7993                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7994                            }
7995                            nondecreasing_exprs__ = 
7996                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7997                                    .into_iter().map(|x| x.0).collect())
7998                            ;
7999                        }
8000                        GeneratedField::NoopUpdateHint => {
8001                            if noop_update_hint__.is_some() {
8002                                return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8003                            }
8004                            noop_update_hint__ = Some(map_.next_value()?);
8005                        }
8006                    }
8007                }
8008                Ok(ProjectNode {
8009                    select_list: select_list__.unwrap_or_default(),
8010                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8011                    watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8012                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8013                    noop_update_hint: noop_update_hint__.unwrap_or_default(),
8014                })
8015            }
8016        }
8017        deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8018    }
8019}
8020impl serde::Serialize for ProjectSetNode {
8021    #[allow(deprecated)]
8022    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8023    where
8024        S: serde::Serializer,
8025    {
8026        use serde::ser::SerializeStruct;
8027        let mut len = 0;
8028        if !self.select_list.is_empty() {
8029            len += 1;
8030        }
8031        if !self.watermark_input_cols.is_empty() {
8032            len += 1;
8033        }
8034        if !self.watermark_expr_indices.is_empty() {
8035            len += 1;
8036        }
8037        if !self.nondecreasing_exprs.is_empty() {
8038            len += 1;
8039        }
8040        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8041        if !self.select_list.is_empty() {
8042            struct_ser.serialize_field("selectList", &self.select_list)?;
8043        }
8044        if !self.watermark_input_cols.is_empty() {
8045            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8046        }
8047        if !self.watermark_expr_indices.is_empty() {
8048            struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8049        }
8050        if !self.nondecreasing_exprs.is_empty() {
8051            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8052        }
8053        struct_ser.end()
8054    }
8055}
8056impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8057    #[allow(deprecated)]
8058    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8059    where
8060        D: serde::Deserializer<'de>,
8061    {
8062        const FIELDS: &[&str] = &[
8063            "select_list",
8064            "selectList",
8065            "watermark_input_cols",
8066            "watermarkInputCols",
8067            "watermark_expr_indices",
8068            "watermarkExprIndices",
8069            "nondecreasing_exprs",
8070            "nondecreasingExprs",
8071        ];
8072
8073        #[allow(clippy::enum_variant_names)]
8074        enum GeneratedField {
8075            SelectList,
8076            WatermarkInputCols,
8077            WatermarkExprIndices,
8078            NondecreasingExprs,
8079        }
8080        impl<'de> serde::Deserialize<'de> for GeneratedField {
8081            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8082            where
8083                D: serde::Deserializer<'de>,
8084            {
8085                struct GeneratedVisitor;
8086
8087                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8088                    type Value = GeneratedField;
8089
8090                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8091                        write!(formatter, "expected one of: {:?}", &FIELDS)
8092                    }
8093
8094                    #[allow(unused_variables)]
8095                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8096                    where
8097                        E: serde::de::Error,
8098                    {
8099                        match value {
8100                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8101                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8102                            "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8103                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8104                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8105                        }
8106                    }
8107                }
8108                deserializer.deserialize_identifier(GeneratedVisitor)
8109            }
8110        }
8111        struct GeneratedVisitor;
8112        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8113            type Value = ProjectSetNode;
8114
8115            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8116                formatter.write_str("struct stream_plan.ProjectSetNode")
8117            }
8118
8119            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8120                where
8121                    V: serde::de::MapAccess<'de>,
8122            {
8123                let mut select_list__ = None;
8124                let mut watermark_input_cols__ = None;
8125                let mut watermark_expr_indices__ = None;
8126                let mut nondecreasing_exprs__ = None;
8127                while let Some(k) = map_.next_key()? {
8128                    match k {
8129                        GeneratedField::SelectList => {
8130                            if select_list__.is_some() {
8131                                return Err(serde::de::Error::duplicate_field("selectList"));
8132                            }
8133                            select_list__ = Some(map_.next_value()?);
8134                        }
8135                        GeneratedField::WatermarkInputCols => {
8136                            if watermark_input_cols__.is_some() {
8137                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8138                            }
8139                            watermark_input_cols__ = 
8140                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8141                                    .into_iter().map(|x| x.0).collect())
8142                            ;
8143                        }
8144                        GeneratedField::WatermarkExprIndices => {
8145                            if watermark_expr_indices__.is_some() {
8146                                return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8147                            }
8148                            watermark_expr_indices__ = 
8149                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8150                                    .into_iter().map(|x| x.0).collect())
8151                            ;
8152                        }
8153                        GeneratedField::NondecreasingExprs => {
8154                            if nondecreasing_exprs__.is_some() {
8155                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8156                            }
8157                            nondecreasing_exprs__ = 
8158                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8159                                    .into_iter().map(|x| x.0).collect())
8160                            ;
8161                        }
8162                    }
8163                }
8164                Ok(ProjectSetNode {
8165                    select_list: select_list__.unwrap_or_default(),
8166                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8167                    watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8168                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8169                })
8170            }
8171        }
8172        deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8173    }
8174}
8175impl serde::Serialize for RefreshStartMutation {
8176    #[allow(deprecated)]
8177    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8178    where
8179        S: serde::Serializer,
8180    {
8181        use serde::ser::SerializeStruct;
8182        let mut len = 0;
8183        if self.table_id != 0 {
8184            len += 1;
8185        }
8186        if self.associated_source_id != 0 {
8187            len += 1;
8188        }
8189        let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8190        if self.table_id != 0 {
8191            struct_ser.serialize_field("tableId", &self.table_id)?;
8192        }
8193        if self.associated_source_id != 0 {
8194            struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8195        }
8196        struct_ser.end()
8197    }
8198}
8199impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8200    #[allow(deprecated)]
8201    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8202    where
8203        D: serde::Deserializer<'de>,
8204    {
8205        const FIELDS: &[&str] = &[
8206            "table_id",
8207            "tableId",
8208            "associated_source_id",
8209            "associatedSourceId",
8210        ];
8211
8212        #[allow(clippy::enum_variant_names)]
8213        enum GeneratedField {
8214            TableId,
8215            AssociatedSourceId,
8216        }
8217        impl<'de> serde::Deserialize<'de> for GeneratedField {
8218            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8219            where
8220                D: serde::Deserializer<'de>,
8221            {
8222                struct GeneratedVisitor;
8223
8224                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8225                    type Value = GeneratedField;
8226
8227                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8228                        write!(formatter, "expected one of: {:?}", &FIELDS)
8229                    }
8230
8231                    #[allow(unused_variables)]
8232                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8233                    where
8234                        E: serde::de::Error,
8235                    {
8236                        match value {
8237                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
8238                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8239                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8240                        }
8241                    }
8242                }
8243                deserializer.deserialize_identifier(GeneratedVisitor)
8244            }
8245        }
8246        struct GeneratedVisitor;
8247        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8248            type Value = RefreshStartMutation;
8249
8250            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8251                formatter.write_str("struct stream_plan.RefreshStartMutation")
8252            }
8253
8254            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8255                where
8256                    V: serde::de::MapAccess<'de>,
8257            {
8258                let mut table_id__ = None;
8259                let mut associated_source_id__ = None;
8260                while let Some(k) = map_.next_key()? {
8261                    match k {
8262                        GeneratedField::TableId => {
8263                            if table_id__.is_some() {
8264                                return Err(serde::de::Error::duplicate_field("tableId"));
8265                            }
8266                            table_id__ = 
8267                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8268                            ;
8269                        }
8270                        GeneratedField::AssociatedSourceId => {
8271                            if associated_source_id__.is_some() {
8272                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8273                            }
8274                            associated_source_id__ = 
8275                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8276                            ;
8277                        }
8278                    }
8279                }
8280                Ok(RefreshStartMutation {
8281                    table_id: table_id__.unwrap_or_default(),
8282                    associated_source_id: associated_source_id__.unwrap_or_default(),
8283                })
8284            }
8285        }
8286        deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8287    }
8288}
8289impl serde::Serialize for ResumeMutation {
8290    #[allow(deprecated)]
8291    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8292    where
8293        S: serde::Serializer,
8294    {
8295        use serde::ser::SerializeStruct;
8296        let len = 0;
8297        let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8298        struct_ser.end()
8299    }
8300}
8301impl<'de> serde::Deserialize<'de> for ResumeMutation {
8302    #[allow(deprecated)]
8303    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8304    where
8305        D: serde::Deserializer<'de>,
8306    {
8307        const FIELDS: &[&str] = &[
8308        ];
8309
8310        #[allow(clippy::enum_variant_names)]
8311        enum GeneratedField {
8312        }
8313        impl<'de> serde::Deserialize<'de> for GeneratedField {
8314            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8315            where
8316                D: serde::Deserializer<'de>,
8317            {
8318                struct GeneratedVisitor;
8319
8320                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8321                    type Value = GeneratedField;
8322
8323                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8324                        write!(formatter, "expected one of: {:?}", &FIELDS)
8325                    }
8326
8327                    #[allow(unused_variables)]
8328                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8329                    where
8330                        E: serde::de::Error,
8331                    {
8332                            Err(serde::de::Error::unknown_field(value, FIELDS))
8333                    }
8334                }
8335                deserializer.deserialize_identifier(GeneratedVisitor)
8336            }
8337        }
8338        struct GeneratedVisitor;
8339        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8340            type Value = ResumeMutation;
8341
8342            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8343                formatter.write_str("struct stream_plan.ResumeMutation")
8344            }
8345
8346            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8347                where
8348                    V: serde::de::MapAccess<'de>,
8349            {
8350                while map_.next_key::<GeneratedField>()?.is_some() {
8351                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8352                }
8353                Ok(ResumeMutation {
8354                })
8355            }
8356        }
8357        deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8358    }
8359}
8360impl serde::Serialize for RowIdGenNode {
8361    #[allow(deprecated)]
8362    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8363    where
8364        S: serde::Serializer,
8365    {
8366        use serde::ser::SerializeStruct;
8367        let mut len = 0;
8368        if self.row_id_index != 0 {
8369            len += 1;
8370        }
8371        let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8372        if self.row_id_index != 0 {
8373            #[allow(clippy::needless_borrow)]
8374            #[allow(clippy::needless_borrows_for_generic_args)]
8375            struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8376        }
8377        struct_ser.end()
8378    }
8379}
8380impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8381    #[allow(deprecated)]
8382    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8383    where
8384        D: serde::Deserializer<'de>,
8385    {
8386        const FIELDS: &[&str] = &[
8387            "row_id_index",
8388            "rowIdIndex",
8389        ];
8390
8391        #[allow(clippy::enum_variant_names)]
8392        enum GeneratedField {
8393            RowIdIndex,
8394        }
8395        impl<'de> serde::Deserialize<'de> for GeneratedField {
8396            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8397            where
8398                D: serde::Deserializer<'de>,
8399            {
8400                struct GeneratedVisitor;
8401
8402                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8403                    type Value = GeneratedField;
8404
8405                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8406                        write!(formatter, "expected one of: {:?}", &FIELDS)
8407                    }
8408
8409                    #[allow(unused_variables)]
8410                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8411                    where
8412                        E: serde::de::Error,
8413                    {
8414                        match value {
8415                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8416                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8417                        }
8418                    }
8419                }
8420                deserializer.deserialize_identifier(GeneratedVisitor)
8421            }
8422        }
8423        struct GeneratedVisitor;
8424        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8425            type Value = RowIdGenNode;
8426
8427            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8428                formatter.write_str("struct stream_plan.RowIdGenNode")
8429            }
8430
8431            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8432                where
8433                    V: serde::de::MapAccess<'de>,
8434            {
8435                let mut row_id_index__ = None;
8436                while let Some(k) = map_.next_key()? {
8437                    match k {
8438                        GeneratedField::RowIdIndex => {
8439                            if row_id_index__.is_some() {
8440                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8441                            }
8442                            row_id_index__ = 
8443                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8444                            ;
8445                        }
8446                    }
8447                }
8448                Ok(RowIdGenNode {
8449                    row_id_index: row_id_index__.unwrap_or_default(),
8450                })
8451            }
8452        }
8453        deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8454    }
8455}
8456impl serde::Serialize for RowMergeNode {
8457    #[allow(deprecated)]
8458    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8459    where
8460        S: serde::Serializer,
8461    {
8462        use serde::ser::SerializeStruct;
8463        let mut len = 0;
8464        if self.lhs_mapping.is_some() {
8465            len += 1;
8466        }
8467        if self.rhs_mapping.is_some() {
8468            len += 1;
8469        }
8470        let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8471        if let Some(v) = self.lhs_mapping.as_ref() {
8472            struct_ser.serialize_field("lhsMapping", v)?;
8473        }
8474        if let Some(v) = self.rhs_mapping.as_ref() {
8475            struct_ser.serialize_field("rhsMapping", v)?;
8476        }
8477        struct_ser.end()
8478    }
8479}
8480impl<'de> serde::Deserialize<'de> for RowMergeNode {
8481    #[allow(deprecated)]
8482    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8483    where
8484        D: serde::Deserializer<'de>,
8485    {
8486        const FIELDS: &[&str] = &[
8487            "lhs_mapping",
8488            "lhsMapping",
8489            "rhs_mapping",
8490            "rhsMapping",
8491        ];
8492
8493        #[allow(clippy::enum_variant_names)]
8494        enum GeneratedField {
8495            LhsMapping,
8496            RhsMapping,
8497        }
8498        impl<'de> serde::Deserialize<'de> for GeneratedField {
8499            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8500            where
8501                D: serde::Deserializer<'de>,
8502            {
8503                struct GeneratedVisitor;
8504
8505                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8506                    type Value = GeneratedField;
8507
8508                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8509                        write!(formatter, "expected one of: {:?}", &FIELDS)
8510                    }
8511
8512                    #[allow(unused_variables)]
8513                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8514                    where
8515                        E: serde::de::Error,
8516                    {
8517                        match value {
8518                            "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8519                            "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8520                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8521                        }
8522                    }
8523                }
8524                deserializer.deserialize_identifier(GeneratedVisitor)
8525            }
8526        }
8527        struct GeneratedVisitor;
8528        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8529            type Value = RowMergeNode;
8530
8531            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8532                formatter.write_str("struct stream_plan.RowMergeNode")
8533            }
8534
8535            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8536                where
8537                    V: serde::de::MapAccess<'de>,
8538            {
8539                let mut lhs_mapping__ = None;
8540                let mut rhs_mapping__ = None;
8541                while let Some(k) = map_.next_key()? {
8542                    match k {
8543                        GeneratedField::LhsMapping => {
8544                            if lhs_mapping__.is_some() {
8545                                return Err(serde::de::Error::duplicate_field("lhsMapping"));
8546                            }
8547                            lhs_mapping__ = map_.next_value()?;
8548                        }
8549                        GeneratedField::RhsMapping => {
8550                            if rhs_mapping__.is_some() {
8551                                return Err(serde::de::Error::duplicate_field("rhsMapping"));
8552                            }
8553                            rhs_mapping__ = map_.next_value()?;
8554                        }
8555                    }
8556                }
8557                Ok(RowMergeNode {
8558                    lhs_mapping: lhs_mapping__,
8559                    rhs_mapping: rhs_mapping__,
8560                })
8561            }
8562        }
8563        deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8564    }
8565}
8566impl serde::Serialize for SimpleAggNode {
8567    #[allow(deprecated)]
8568    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8569    where
8570        S: serde::Serializer,
8571    {
8572        use serde::ser::SerializeStruct;
8573        let mut len = 0;
8574        if !self.agg_calls.is_empty() {
8575            len += 1;
8576        }
8577        if !self.agg_call_states.is_empty() {
8578            len += 1;
8579        }
8580        if self.intermediate_state_table.is_some() {
8581            len += 1;
8582        }
8583        if self.is_append_only {
8584            len += 1;
8585        }
8586        if !self.distinct_dedup_tables.is_empty() {
8587            len += 1;
8588        }
8589        if self.row_count_index != 0 {
8590            len += 1;
8591        }
8592        if self.version != 0 {
8593            len += 1;
8594        }
8595        if self.must_output_per_barrier {
8596            len += 1;
8597        }
8598        let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8599        if !self.agg_calls.is_empty() {
8600            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8601        }
8602        if !self.agg_call_states.is_empty() {
8603            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8604        }
8605        if let Some(v) = self.intermediate_state_table.as_ref() {
8606            struct_ser.serialize_field("intermediateStateTable", v)?;
8607        }
8608        if self.is_append_only {
8609            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8610        }
8611        if !self.distinct_dedup_tables.is_empty() {
8612            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8613        }
8614        if self.row_count_index != 0 {
8615            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8616        }
8617        if self.version != 0 {
8618            let v = AggNodeVersion::try_from(self.version)
8619                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8620            struct_ser.serialize_field("version", &v)?;
8621        }
8622        if self.must_output_per_barrier {
8623            struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8624        }
8625        struct_ser.end()
8626    }
8627}
8628impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8629    #[allow(deprecated)]
8630    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8631    where
8632        D: serde::Deserializer<'de>,
8633    {
8634        const FIELDS: &[&str] = &[
8635            "agg_calls",
8636            "aggCalls",
8637            "agg_call_states",
8638            "aggCallStates",
8639            "intermediate_state_table",
8640            "intermediateStateTable",
8641            "is_append_only",
8642            "isAppendOnly",
8643            "distinct_dedup_tables",
8644            "distinctDedupTables",
8645            "row_count_index",
8646            "rowCountIndex",
8647            "version",
8648            "must_output_per_barrier",
8649            "mustOutputPerBarrier",
8650        ];
8651
8652        #[allow(clippy::enum_variant_names)]
8653        enum GeneratedField {
8654            AggCalls,
8655            AggCallStates,
8656            IntermediateStateTable,
8657            IsAppendOnly,
8658            DistinctDedupTables,
8659            RowCountIndex,
8660            Version,
8661            MustOutputPerBarrier,
8662        }
8663        impl<'de> serde::Deserialize<'de> for GeneratedField {
8664            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8665            where
8666                D: serde::Deserializer<'de>,
8667            {
8668                struct GeneratedVisitor;
8669
8670                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8671                    type Value = GeneratedField;
8672
8673                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8674                        write!(formatter, "expected one of: {:?}", &FIELDS)
8675                    }
8676
8677                    #[allow(unused_variables)]
8678                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8679                    where
8680                        E: serde::de::Error,
8681                    {
8682                        match value {
8683                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8684                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8685                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8686                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8687                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8688                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8689                            "version" => Ok(GeneratedField::Version),
8690                            "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8691                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8692                        }
8693                    }
8694                }
8695                deserializer.deserialize_identifier(GeneratedVisitor)
8696            }
8697        }
8698        struct GeneratedVisitor;
8699        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8700            type Value = SimpleAggNode;
8701
8702            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8703                formatter.write_str("struct stream_plan.SimpleAggNode")
8704            }
8705
8706            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8707                where
8708                    V: serde::de::MapAccess<'de>,
8709            {
8710                let mut agg_calls__ = None;
8711                let mut agg_call_states__ = None;
8712                let mut intermediate_state_table__ = None;
8713                let mut is_append_only__ = None;
8714                let mut distinct_dedup_tables__ = None;
8715                let mut row_count_index__ = None;
8716                let mut version__ = None;
8717                let mut must_output_per_barrier__ = None;
8718                while let Some(k) = map_.next_key()? {
8719                    match k {
8720                        GeneratedField::AggCalls => {
8721                            if agg_calls__.is_some() {
8722                                return Err(serde::de::Error::duplicate_field("aggCalls"));
8723                            }
8724                            agg_calls__ = Some(map_.next_value()?);
8725                        }
8726                        GeneratedField::AggCallStates => {
8727                            if agg_call_states__.is_some() {
8728                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
8729                            }
8730                            agg_call_states__ = Some(map_.next_value()?);
8731                        }
8732                        GeneratedField::IntermediateStateTable => {
8733                            if intermediate_state_table__.is_some() {
8734                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8735                            }
8736                            intermediate_state_table__ = map_.next_value()?;
8737                        }
8738                        GeneratedField::IsAppendOnly => {
8739                            if is_append_only__.is_some() {
8740                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8741                            }
8742                            is_append_only__ = Some(map_.next_value()?);
8743                        }
8744                        GeneratedField::DistinctDedupTables => {
8745                            if distinct_dedup_tables__.is_some() {
8746                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8747                            }
8748                            distinct_dedup_tables__ = Some(
8749                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8750                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8751                            );
8752                        }
8753                        GeneratedField::RowCountIndex => {
8754                            if row_count_index__.is_some() {
8755                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8756                            }
8757                            row_count_index__ = 
8758                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8759                            ;
8760                        }
8761                        GeneratedField::Version => {
8762                            if version__.is_some() {
8763                                return Err(serde::de::Error::duplicate_field("version"));
8764                            }
8765                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8766                        }
8767                        GeneratedField::MustOutputPerBarrier => {
8768                            if must_output_per_barrier__.is_some() {
8769                                return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8770                            }
8771                            must_output_per_barrier__ = Some(map_.next_value()?);
8772                        }
8773                    }
8774                }
8775                Ok(SimpleAggNode {
8776                    agg_calls: agg_calls__.unwrap_or_default(),
8777                    agg_call_states: agg_call_states__.unwrap_or_default(),
8778                    intermediate_state_table: intermediate_state_table__,
8779                    is_append_only: is_append_only__.unwrap_or_default(),
8780                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8781                    row_count_index: row_count_index__.unwrap_or_default(),
8782                    version: version__.unwrap_or_default(),
8783                    must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8784                })
8785            }
8786        }
8787        deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8788    }
8789}
8790impl serde::Serialize for SinkAddColumns {
8791    #[allow(deprecated)]
8792    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8793    where
8794        S: serde::Serializer,
8795    {
8796        use serde::ser::SerializeStruct;
8797        let mut len = 0;
8798        if !self.fields.is_empty() {
8799            len += 1;
8800        }
8801        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
8802        if !self.fields.is_empty() {
8803            struct_ser.serialize_field("fields", &self.fields)?;
8804        }
8805        struct_ser.end()
8806    }
8807}
8808impl<'de> serde::Deserialize<'de> for SinkAddColumns {
8809    #[allow(deprecated)]
8810    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8811    where
8812        D: serde::Deserializer<'de>,
8813    {
8814        const FIELDS: &[&str] = &[
8815            "fields",
8816        ];
8817
8818        #[allow(clippy::enum_variant_names)]
8819        enum GeneratedField {
8820            Fields,
8821        }
8822        impl<'de> serde::Deserialize<'de> for GeneratedField {
8823            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8824            where
8825                D: serde::Deserializer<'de>,
8826            {
8827                struct GeneratedVisitor;
8828
8829                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8830                    type Value = GeneratedField;
8831
8832                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8833                        write!(formatter, "expected one of: {:?}", &FIELDS)
8834                    }
8835
8836                    #[allow(unused_variables)]
8837                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8838                    where
8839                        E: serde::de::Error,
8840                    {
8841                        match value {
8842                            "fields" => Ok(GeneratedField::Fields),
8843                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8844                        }
8845                    }
8846                }
8847                deserializer.deserialize_identifier(GeneratedVisitor)
8848            }
8849        }
8850        struct GeneratedVisitor;
8851        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8852            type Value = SinkAddColumns;
8853
8854            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8855                formatter.write_str("struct stream_plan.SinkAddColumns")
8856            }
8857
8858            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
8859                where
8860                    V: serde::de::MapAccess<'de>,
8861            {
8862                let mut fields__ = None;
8863                while let Some(k) = map_.next_key()? {
8864                    match k {
8865                        GeneratedField::Fields => {
8866                            if fields__.is_some() {
8867                                return Err(serde::de::Error::duplicate_field("fields"));
8868                            }
8869                            fields__ = Some(map_.next_value()?);
8870                        }
8871                    }
8872                }
8873                Ok(SinkAddColumns {
8874                    fields: fields__.unwrap_or_default(),
8875                })
8876            }
8877        }
8878        deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
8879    }
8880}
8881impl serde::Serialize for SinkDesc {
8882    #[allow(deprecated)]
8883    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8884    where
8885        S: serde::Serializer,
8886    {
8887        use serde::ser::SerializeStruct;
8888        let mut len = 0;
8889        if self.id != 0 {
8890            len += 1;
8891        }
8892        if !self.name.is_empty() {
8893            len += 1;
8894        }
8895        if !self.definition.is_empty() {
8896            len += 1;
8897        }
8898        if !self.plan_pk.is_empty() {
8899            len += 1;
8900        }
8901        if !self.downstream_pk.is_empty() {
8902            len += 1;
8903        }
8904        if !self.distribution_key.is_empty() {
8905            len += 1;
8906        }
8907        if !self.properties.is_empty() {
8908            len += 1;
8909        }
8910        if self.sink_type != 0 {
8911            len += 1;
8912        }
8913        if !self.column_catalogs.is_empty() {
8914            len += 1;
8915        }
8916        if !self.db_name.is_empty() {
8917            len += 1;
8918        }
8919        if !self.sink_from_name.is_empty() {
8920            len += 1;
8921        }
8922        if self.format_desc.is_some() {
8923            len += 1;
8924        }
8925        if self.target_table.is_some() {
8926            len += 1;
8927        }
8928        if self.extra_partition_col_idx.is_some() {
8929            len += 1;
8930        }
8931        if !self.secret_refs.is_empty() {
8932            len += 1;
8933        }
8934        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8935        if self.id != 0 {
8936            struct_ser.serialize_field("id", &self.id)?;
8937        }
8938        if !self.name.is_empty() {
8939            struct_ser.serialize_field("name", &self.name)?;
8940        }
8941        if !self.definition.is_empty() {
8942            struct_ser.serialize_field("definition", &self.definition)?;
8943        }
8944        if !self.plan_pk.is_empty() {
8945            struct_ser.serialize_field("planPk", &self.plan_pk)?;
8946        }
8947        if !self.downstream_pk.is_empty() {
8948            struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8949        }
8950        if !self.distribution_key.is_empty() {
8951            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8952        }
8953        if !self.properties.is_empty() {
8954            struct_ser.serialize_field("properties", &self.properties)?;
8955        }
8956        if self.sink_type != 0 {
8957            let v = super::catalog::SinkType::try_from(self.sink_type)
8958                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8959            struct_ser.serialize_field("sinkType", &v)?;
8960        }
8961        if !self.column_catalogs.is_empty() {
8962            struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8963        }
8964        if !self.db_name.is_empty() {
8965            struct_ser.serialize_field("dbName", &self.db_name)?;
8966        }
8967        if !self.sink_from_name.is_empty() {
8968            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8969        }
8970        if let Some(v) = self.format_desc.as_ref() {
8971            struct_ser.serialize_field("formatDesc", v)?;
8972        }
8973        if let Some(v) = self.target_table.as_ref() {
8974            struct_ser.serialize_field("targetTable", v)?;
8975        }
8976        if let Some(v) = self.extra_partition_col_idx.as_ref() {
8977            #[allow(clippy::needless_borrow)]
8978            #[allow(clippy::needless_borrows_for_generic_args)]
8979            struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8980        }
8981        if !self.secret_refs.is_empty() {
8982            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8983        }
8984        struct_ser.end()
8985    }
8986}
8987impl<'de> serde::Deserialize<'de> for SinkDesc {
8988    #[allow(deprecated)]
8989    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8990    where
8991        D: serde::Deserializer<'de>,
8992    {
8993        const FIELDS: &[&str] = &[
8994            "id",
8995            "name",
8996            "definition",
8997            "plan_pk",
8998            "planPk",
8999            "downstream_pk",
9000            "downstreamPk",
9001            "distribution_key",
9002            "distributionKey",
9003            "properties",
9004            "sink_type",
9005            "sinkType",
9006            "column_catalogs",
9007            "columnCatalogs",
9008            "db_name",
9009            "dbName",
9010            "sink_from_name",
9011            "sinkFromName",
9012            "format_desc",
9013            "formatDesc",
9014            "target_table",
9015            "targetTable",
9016            "extra_partition_col_idx",
9017            "extraPartitionColIdx",
9018            "secret_refs",
9019            "secretRefs",
9020        ];
9021
9022        #[allow(clippy::enum_variant_names)]
9023        enum GeneratedField {
9024            Id,
9025            Name,
9026            Definition,
9027            PlanPk,
9028            DownstreamPk,
9029            DistributionKey,
9030            Properties,
9031            SinkType,
9032            ColumnCatalogs,
9033            DbName,
9034            SinkFromName,
9035            FormatDesc,
9036            TargetTable,
9037            ExtraPartitionColIdx,
9038            SecretRefs,
9039        }
9040        impl<'de> serde::Deserialize<'de> for GeneratedField {
9041            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9042            where
9043                D: serde::Deserializer<'de>,
9044            {
9045                struct GeneratedVisitor;
9046
9047                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9048                    type Value = GeneratedField;
9049
9050                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9051                        write!(formatter, "expected one of: {:?}", &FIELDS)
9052                    }
9053
9054                    #[allow(unused_variables)]
9055                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9056                    where
9057                        E: serde::de::Error,
9058                    {
9059                        match value {
9060                            "id" => Ok(GeneratedField::Id),
9061                            "name" => Ok(GeneratedField::Name),
9062                            "definition" => Ok(GeneratedField::Definition),
9063                            "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9064                            "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9065                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9066                            "properties" => Ok(GeneratedField::Properties),
9067                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9068                            "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9069                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
9070                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9071                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9072                            "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9073                            "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9074                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9075                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9076                        }
9077                    }
9078                }
9079                deserializer.deserialize_identifier(GeneratedVisitor)
9080            }
9081        }
9082        struct GeneratedVisitor;
9083        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9084            type Value = SinkDesc;
9085
9086            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087                formatter.write_str("struct stream_plan.SinkDesc")
9088            }
9089
9090            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9091                where
9092                    V: serde::de::MapAccess<'de>,
9093            {
9094                let mut id__ = None;
9095                let mut name__ = None;
9096                let mut definition__ = None;
9097                let mut plan_pk__ = None;
9098                let mut downstream_pk__ = None;
9099                let mut distribution_key__ = None;
9100                let mut properties__ = None;
9101                let mut sink_type__ = None;
9102                let mut column_catalogs__ = None;
9103                let mut db_name__ = None;
9104                let mut sink_from_name__ = None;
9105                let mut format_desc__ = None;
9106                let mut target_table__ = None;
9107                let mut extra_partition_col_idx__ = None;
9108                let mut secret_refs__ = None;
9109                while let Some(k) = map_.next_key()? {
9110                    match k {
9111                        GeneratedField::Id => {
9112                            if id__.is_some() {
9113                                return Err(serde::de::Error::duplicate_field("id"));
9114                            }
9115                            id__ = 
9116                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9117                            ;
9118                        }
9119                        GeneratedField::Name => {
9120                            if name__.is_some() {
9121                                return Err(serde::de::Error::duplicate_field("name"));
9122                            }
9123                            name__ = Some(map_.next_value()?);
9124                        }
9125                        GeneratedField::Definition => {
9126                            if definition__.is_some() {
9127                                return Err(serde::de::Error::duplicate_field("definition"));
9128                            }
9129                            definition__ = Some(map_.next_value()?);
9130                        }
9131                        GeneratedField::PlanPk => {
9132                            if plan_pk__.is_some() {
9133                                return Err(serde::de::Error::duplicate_field("planPk"));
9134                            }
9135                            plan_pk__ = Some(map_.next_value()?);
9136                        }
9137                        GeneratedField::DownstreamPk => {
9138                            if downstream_pk__.is_some() {
9139                                return Err(serde::de::Error::duplicate_field("downstreamPk"));
9140                            }
9141                            downstream_pk__ = 
9142                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9143                                    .into_iter().map(|x| x.0).collect())
9144                            ;
9145                        }
9146                        GeneratedField::DistributionKey => {
9147                            if distribution_key__.is_some() {
9148                                return Err(serde::de::Error::duplicate_field("distributionKey"));
9149                            }
9150                            distribution_key__ = 
9151                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9152                                    .into_iter().map(|x| x.0).collect())
9153                            ;
9154                        }
9155                        GeneratedField::Properties => {
9156                            if properties__.is_some() {
9157                                return Err(serde::de::Error::duplicate_field("properties"));
9158                            }
9159                            properties__ = Some(
9160                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9161                            );
9162                        }
9163                        GeneratedField::SinkType => {
9164                            if sink_type__.is_some() {
9165                                return Err(serde::de::Error::duplicate_field("sinkType"));
9166                            }
9167                            sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9168                        }
9169                        GeneratedField::ColumnCatalogs => {
9170                            if column_catalogs__.is_some() {
9171                                return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9172                            }
9173                            column_catalogs__ = Some(map_.next_value()?);
9174                        }
9175                        GeneratedField::DbName => {
9176                            if db_name__.is_some() {
9177                                return Err(serde::de::Error::duplicate_field("dbName"));
9178                            }
9179                            db_name__ = Some(map_.next_value()?);
9180                        }
9181                        GeneratedField::SinkFromName => {
9182                            if sink_from_name__.is_some() {
9183                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
9184                            }
9185                            sink_from_name__ = Some(map_.next_value()?);
9186                        }
9187                        GeneratedField::FormatDesc => {
9188                            if format_desc__.is_some() {
9189                                return Err(serde::de::Error::duplicate_field("formatDesc"));
9190                            }
9191                            format_desc__ = map_.next_value()?;
9192                        }
9193                        GeneratedField::TargetTable => {
9194                            if target_table__.is_some() {
9195                                return Err(serde::de::Error::duplicate_field("targetTable"));
9196                            }
9197                            target_table__ = 
9198                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9199                            ;
9200                        }
9201                        GeneratedField::ExtraPartitionColIdx => {
9202                            if extra_partition_col_idx__.is_some() {
9203                                return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9204                            }
9205                            extra_partition_col_idx__ = 
9206                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9207                            ;
9208                        }
9209                        GeneratedField::SecretRefs => {
9210                            if secret_refs__.is_some() {
9211                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9212                            }
9213                            secret_refs__ = Some(
9214                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9215                            );
9216                        }
9217                    }
9218                }
9219                Ok(SinkDesc {
9220                    id: id__.unwrap_or_default(),
9221                    name: name__.unwrap_or_default(),
9222                    definition: definition__.unwrap_or_default(),
9223                    plan_pk: plan_pk__.unwrap_or_default(),
9224                    downstream_pk: downstream_pk__.unwrap_or_default(),
9225                    distribution_key: distribution_key__.unwrap_or_default(),
9226                    properties: properties__.unwrap_or_default(),
9227                    sink_type: sink_type__.unwrap_or_default(),
9228                    column_catalogs: column_catalogs__.unwrap_or_default(),
9229                    db_name: db_name__.unwrap_or_default(),
9230                    sink_from_name: sink_from_name__.unwrap_or_default(),
9231                    format_desc: format_desc__,
9232                    target_table: target_table__,
9233                    extra_partition_col_idx: extra_partition_col_idx__,
9234                    secret_refs: secret_refs__.unwrap_or_default(),
9235                })
9236            }
9237        }
9238        deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9239    }
9240}
9241impl serde::Serialize for SinkLogStoreType {
9242    #[allow(deprecated)]
9243    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9244    where
9245        S: serde::Serializer,
9246    {
9247        let variant = match self {
9248            Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9249            Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9250            Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9251        };
9252        serializer.serialize_str(variant)
9253    }
9254}
9255impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9256    #[allow(deprecated)]
9257    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9258    where
9259        D: serde::Deserializer<'de>,
9260    {
9261        const FIELDS: &[&str] = &[
9262            "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9263            "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9264            "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9265        ];
9266
9267        struct GeneratedVisitor;
9268
9269        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9270            type Value = SinkLogStoreType;
9271
9272            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9273                write!(formatter, "expected one of: {:?}", &FIELDS)
9274            }
9275
9276            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9277            where
9278                E: serde::de::Error,
9279            {
9280                i32::try_from(v)
9281                    .ok()
9282                    .and_then(|x| x.try_into().ok())
9283                    .ok_or_else(|| {
9284                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9285                    })
9286            }
9287
9288            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9289            where
9290                E: serde::de::Error,
9291            {
9292                i32::try_from(v)
9293                    .ok()
9294                    .and_then(|x| x.try_into().ok())
9295                    .ok_or_else(|| {
9296                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9297                    })
9298            }
9299
9300            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9301            where
9302                E: serde::de::Error,
9303            {
9304                match value {
9305                    "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9306                    "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9307                    "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9308                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9309                }
9310            }
9311        }
9312        deserializer.deserialize_any(GeneratedVisitor)
9313    }
9314}
9315impl serde::Serialize for SinkNode {
9316    #[allow(deprecated)]
9317    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9318    where
9319        S: serde::Serializer,
9320    {
9321        use serde::ser::SerializeStruct;
9322        let mut len = 0;
9323        if self.sink_desc.is_some() {
9324            len += 1;
9325        }
9326        if self.table.is_some() {
9327            len += 1;
9328        }
9329        if self.log_store_type != 0 {
9330            len += 1;
9331        }
9332        if self.rate_limit.is_some() {
9333            len += 1;
9334        }
9335        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9336        if let Some(v) = self.sink_desc.as_ref() {
9337            struct_ser.serialize_field("sinkDesc", v)?;
9338        }
9339        if let Some(v) = self.table.as_ref() {
9340            struct_ser.serialize_field("table", v)?;
9341        }
9342        if self.log_store_type != 0 {
9343            let v = SinkLogStoreType::try_from(self.log_store_type)
9344                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9345            struct_ser.serialize_field("logStoreType", &v)?;
9346        }
9347        if let Some(v) = self.rate_limit.as_ref() {
9348            struct_ser.serialize_field("rateLimit", v)?;
9349        }
9350        struct_ser.end()
9351    }
9352}
9353impl<'de> serde::Deserialize<'de> for SinkNode {
9354    #[allow(deprecated)]
9355    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9356    where
9357        D: serde::Deserializer<'de>,
9358    {
9359        const FIELDS: &[&str] = &[
9360            "sink_desc",
9361            "sinkDesc",
9362            "table",
9363            "log_store_type",
9364            "logStoreType",
9365            "rate_limit",
9366            "rateLimit",
9367        ];
9368
9369        #[allow(clippy::enum_variant_names)]
9370        enum GeneratedField {
9371            SinkDesc,
9372            Table,
9373            LogStoreType,
9374            RateLimit,
9375        }
9376        impl<'de> serde::Deserialize<'de> for GeneratedField {
9377            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9378            where
9379                D: serde::Deserializer<'de>,
9380            {
9381                struct GeneratedVisitor;
9382
9383                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9384                    type Value = GeneratedField;
9385
9386                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9387                        write!(formatter, "expected one of: {:?}", &FIELDS)
9388                    }
9389
9390                    #[allow(unused_variables)]
9391                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9392                    where
9393                        E: serde::de::Error,
9394                    {
9395                        match value {
9396                            "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9397                            "table" => Ok(GeneratedField::Table),
9398                            "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9399                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9400                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9401                        }
9402                    }
9403                }
9404                deserializer.deserialize_identifier(GeneratedVisitor)
9405            }
9406        }
9407        struct GeneratedVisitor;
9408        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9409            type Value = SinkNode;
9410
9411            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9412                formatter.write_str("struct stream_plan.SinkNode")
9413            }
9414
9415            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9416                where
9417                    V: serde::de::MapAccess<'de>,
9418            {
9419                let mut sink_desc__ = None;
9420                let mut table__ = None;
9421                let mut log_store_type__ = None;
9422                let mut rate_limit__ = None;
9423                while let Some(k) = map_.next_key()? {
9424                    match k {
9425                        GeneratedField::SinkDesc => {
9426                            if sink_desc__.is_some() {
9427                                return Err(serde::de::Error::duplicate_field("sinkDesc"));
9428                            }
9429                            sink_desc__ = map_.next_value()?;
9430                        }
9431                        GeneratedField::Table => {
9432                            if table__.is_some() {
9433                                return Err(serde::de::Error::duplicate_field("table"));
9434                            }
9435                            table__ = map_.next_value()?;
9436                        }
9437                        GeneratedField::LogStoreType => {
9438                            if log_store_type__.is_some() {
9439                                return Err(serde::de::Error::duplicate_field("logStoreType"));
9440                            }
9441                            log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
9442                        }
9443                        GeneratedField::RateLimit => {
9444                            if rate_limit__.is_some() {
9445                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9446                            }
9447                            rate_limit__ = 
9448                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9449                            ;
9450                        }
9451                    }
9452                }
9453                Ok(SinkNode {
9454                    sink_desc: sink_desc__,
9455                    table: table__,
9456                    log_store_type: log_store_type__.unwrap_or_default(),
9457                    rate_limit: rate_limit__,
9458                })
9459            }
9460        }
9461        deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
9462    }
9463}
9464impl serde::Serialize for SortNode {
9465    #[allow(deprecated)]
9466    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9467    where
9468        S: serde::Serializer,
9469    {
9470        use serde::ser::SerializeStruct;
9471        let mut len = 0;
9472        if self.state_table.is_some() {
9473            len += 1;
9474        }
9475        if self.sort_column_index != 0 {
9476            len += 1;
9477        }
9478        let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
9479        if let Some(v) = self.state_table.as_ref() {
9480            struct_ser.serialize_field("stateTable", v)?;
9481        }
9482        if self.sort_column_index != 0 {
9483            struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
9484        }
9485        struct_ser.end()
9486    }
9487}
9488impl<'de> serde::Deserialize<'de> for SortNode {
9489    #[allow(deprecated)]
9490    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9491    where
9492        D: serde::Deserializer<'de>,
9493    {
9494        const FIELDS: &[&str] = &[
9495            "state_table",
9496            "stateTable",
9497            "sort_column_index",
9498            "sortColumnIndex",
9499        ];
9500
9501        #[allow(clippy::enum_variant_names)]
9502        enum GeneratedField {
9503            StateTable,
9504            SortColumnIndex,
9505        }
9506        impl<'de> serde::Deserialize<'de> for GeneratedField {
9507            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9508            where
9509                D: serde::Deserializer<'de>,
9510            {
9511                struct GeneratedVisitor;
9512
9513                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9514                    type Value = GeneratedField;
9515
9516                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9517                        write!(formatter, "expected one of: {:?}", &FIELDS)
9518                    }
9519
9520                    #[allow(unused_variables)]
9521                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9522                    where
9523                        E: serde::de::Error,
9524                    {
9525                        match value {
9526                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9527                            "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9528                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9529                        }
9530                    }
9531                }
9532                deserializer.deserialize_identifier(GeneratedVisitor)
9533            }
9534        }
9535        struct GeneratedVisitor;
9536        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9537            type Value = SortNode;
9538
9539            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9540                formatter.write_str("struct stream_plan.SortNode")
9541            }
9542
9543            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9544                where
9545                    V: serde::de::MapAccess<'de>,
9546            {
9547                let mut state_table__ = None;
9548                let mut sort_column_index__ = None;
9549                while let Some(k) = map_.next_key()? {
9550                    match k {
9551                        GeneratedField::StateTable => {
9552                            if state_table__.is_some() {
9553                                return Err(serde::de::Error::duplicate_field("stateTable"));
9554                            }
9555                            state_table__ = map_.next_value()?;
9556                        }
9557                        GeneratedField::SortColumnIndex => {
9558                            if sort_column_index__.is_some() {
9559                                return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9560                            }
9561                            sort_column_index__ = 
9562                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9563                            ;
9564                        }
9565                    }
9566                }
9567                Ok(SortNode {
9568                    state_table: state_table__,
9569                    sort_column_index: sort_column_index__.unwrap_or_default(),
9570                })
9571            }
9572        }
9573        deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9574    }
9575}
9576impl serde::Serialize for SourceBackfillNode {
9577    #[allow(deprecated)]
9578    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9579    where
9580        S: serde::Serializer,
9581    {
9582        use serde::ser::SerializeStruct;
9583        let mut len = 0;
9584        if self.upstream_source_id != 0 {
9585            len += 1;
9586        }
9587        if self.row_id_index.is_some() {
9588            len += 1;
9589        }
9590        if !self.columns.is_empty() {
9591            len += 1;
9592        }
9593        if self.info.is_some() {
9594            len += 1;
9595        }
9596        if !self.source_name.is_empty() {
9597            len += 1;
9598        }
9599        if !self.with_properties.is_empty() {
9600            len += 1;
9601        }
9602        if self.rate_limit.is_some() {
9603            len += 1;
9604        }
9605        if self.state_table.is_some() {
9606            len += 1;
9607        }
9608        if !self.secret_refs.is_empty() {
9609            len += 1;
9610        }
9611        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9612        if self.upstream_source_id != 0 {
9613            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9614        }
9615        if let Some(v) = self.row_id_index.as_ref() {
9616            struct_ser.serialize_field("rowIdIndex", v)?;
9617        }
9618        if !self.columns.is_empty() {
9619            struct_ser.serialize_field("columns", &self.columns)?;
9620        }
9621        if let Some(v) = self.info.as_ref() {
9622            struct_ser.serialize_field("info", v)?;
9623        }
9624        if !self.source_name.is_empty() {
9625            struct_ser.serialize_field("sourceName", &self.source_name)?;
9626        }
9627        if !self.with_properties.is_empty() {
9628            struct_ser.serialize_field("withProperties", &self.with_properties)?;
9629        }
9630        if let Some(v) = self.rate_limit.as_ref() {
9631            struct_ser.serialize_field("rateLimit", v)?;
9632        }
9633        if let Some(v) = self.state_table.as_ref() {
9634            struct_ser.serialize_field("stateTable", v)?;
9635        }
9636        if !self.secret_refs.is_empty() {
9637            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9638        }
9639        struct_ser.end()
9640    }
9641}
9642impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9643    #[allow(deprecated)]
9644    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9645    where
9646        D: serde::Deserializer<'de>,
9647    {
9648        const FIELDS: &[&str] = &[
9649            "upstream_source_id",
9650            "upstreamSourceId",
9651            "row_id_index",
9652            "rowIdIndex",
9653            "columns",
9654            "info",
9655            "source_name",
9656            "sourceName",
9657            "with_properties",
9658            "withProperties",
9659            "rate_limit",
9660            "rateLimit",
9661            "state_table",
9662            "stateTable",
9663            "secret_refs",
9664            "secretRefs",
9665        ];
9666
9667        #[allow(clippy::enum_variant_names)]
9668        enum GeneratedField {
9669            UpstreamSourceId,
9670            RowIdIndex,
9671            Columns,
9672            Info,
9673            SourceName,
9674            WithProperties,
9675            RateLimit,
9676            StateTable,
9677            SecretRefs,
9678        }
9679        impl<'de> serde::Deserialize<'de> for GeneratedField {
9680            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9681            where
9682                D: serde::Deserializer<'de>,
9683            {
9684                struct GeneratedVisitor;
9685
9686                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9687                    type Value = GeneratedField;
9688
9689                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9690                        write!(formatter, "expected one of: {:?}", &FIELDS)
9691                    }
9692
9693                    #[allow(unused_variables)]
9694                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9695                    where
9696                        E: serde::de::Error,
9697                    {
9698                        match value {
9699                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9700                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9701                            "columns" => Ok(GeneratedField::Columns),
9702                            "info" => Ok(GeneratedField::Info),
9703                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9704                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9705                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9706                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9707                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9708                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9709                        }
9710                    }
9711                }
9712                deserializer.deserialize_identifier(GeneratedVisitor)
9713            }
9714        }
9715        struct GeneratedVisitor;
9716        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9717            type Value = SourceBackfillNode;
9718
9719            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9720                formatter.write_str("struct stream_plan.SourceBackfillNode")
9721            }
9722
9723            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9724                where
9725                    V: serde::de::MapAccess<'de>,
9726            {
9727                let mut upstream_source_id__ = None;
9728                let mut row_id_index__ = None;
9729                let mut columns__ = None;
9730                let mut info__ = None;
9731                let mut source_name__ = None;
9732                let mut with_properties__ = None;
9733                let mut rate_limit__ = None;
9734                let mut state_table__ = None;
9735                let mut secret_refs__ = None;
9736                while let Some(k) = map_.next_key()? {
9737                    match k {
9738                        GeneratedField::UpstreamSourceId => {
9739                            if upstream_source_id__.is_some() {
9740                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9741                            }
9742                            upstream_source_id__ = 
9743                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9744                            ;
9745                        }
9746                        GeneratedField::RowIdIndex => {
9747                            if row_id_index__.is_some() {
9748                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9749                            }
9750                            row_id_index__ = 
9751                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9752                            ;
9753                        }
9754                        GeneratedField::Columns => {
9755                            if columns__.is_some() {
9756                                return Err(serde::de::Error::duplicate_field("columns"));
9757                            }
9758                            columns__ = Some(map_.next_value()?);
9759                        }
9760                        GeneratedField::Info => {
9761                            if info__.is_some() {
9762                                return Err(serde::de::Error::duplicate_field("info"));
9763                            }
9764                            info__ = map_.next_value()?;
9765                        }
9766                        GeneratedField::SourceName => {
9767                            if source_name__.is_some() {
9768                                return Err(serde::de::Error::duplicate_field("sourceName"));
9769                            }
9770                            source_name__ = Some(map_.next_value()?);
9771                        }
9772                        GeneratedField::WithProperties => {
9773                            if with_properties__.is_some() {
9774                                return Err(serde::de::Error::duplicate_field("withProperties"));
9775                            }
9776                            with_properties__ = Some(
9777                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9778                            );
9779                        }
9780                        GeneratedField::RateLimit => {
9781                            if rate_limit__.is_some() {
9782                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9783                            }
9784                            rate_limit__ = 
9785                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9786                            ;
9787                        }
9788                        GeneratedField::StateTable => {
9789                            if state_table__.is_some() {
9790                                return Err(serde::de::Error::duplicate_field("stateTable"));
9791                            }
9792                            state_table__ = map_.next_value()?;
9793                        }
9794                        GeneratedField::SecretRefs => {
9795                            if secret_refs__.is_some() {
9796                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9797                            }
9798                            secret_refs__ = Some(
9799                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9800                            );
9801                        }
9802                    }
9803                }
9804                Ok(SourceBackfillNode {
9805                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
9806                    row_id_index: row_id_index__,
9807                    columns: columns__.unwrap_or_default(),
9808                    info: info__,
9809                    source_name: source_name__.unwrap_or_default(),
9810                    with_properties: with_properties__.unwrap_or_default(),
9811                    rate_limit: rate_limit__,
9812                    state_table: state_table__,
9813                    secret_refs: secret_refs__.unwrap_or_default(),
9814                })
9815            }
9816        }
9817        deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9818    }
9819}
9820impl serde::Serialize for SourceChangeSplitMutation {
9821    #[allow(deprecated)]
9822    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9823    where
9824        S: serde::Serializer,
9825    {
9826        use serde::ser::SerializeStruct;
9827        let mut len = 0;
9828        if !self.actor_splits.is_empty() {
9829            len += 1;
9830        }
9831        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9832        if !self.actor_splits.is_empty() {
9833            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9834        }
9835        struct_ser.end()
9836    }
9837}
9838impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9839    #[allow(deprecated)]
9840    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9841    where
9842        D: serde::Deserializer<'de>,
9843    {
9844        const FIELDS: &[&str] = &[
9845            "actor_splits",
9846            "actorSplits",
9847        ];
9848
9849        #[allow(clippy::enum_variant_names)]
9850        enum GeneratedField {
9851            ActorSplits,
9852        }
9853        impl<'de> serde::Deserialize<'de> for GeneratedField {
9854            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9855            where
9856                D: serde::Deserializer<'de>,
9857            {
9858                struct GeneratedVisitor;
9859
9860                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9861                    type Value = GeneratedField;
9862
9863                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9864                        write!(formatter, "expected one of: {:?}", &FIELDS)
9865                    }
9866
9867                    #[allow(unused_variables)]
9868                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9869                    where
9870                        E: serde::de::Error,
9871                    {
9872                        match value {
9873                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9874                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9875                        }
9876                    }
9877                }
9878                deserializer.deserialize_identifier(GeneratedVisitor)
9879            }
9880        }
9881        struct GeneratedVisitor;
9882        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9883            type Value = SourceChangeSplitMutation;
9884
9885            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9886                formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9887            }
9888
9889            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9890                where
9891                    V: serde::de::MapAccess<'de>,
9892            {
9893                let mut actor_splits__ = None;
9894                while let Some(k) = map_.next_key()? {
9895                    match k {
9896                        GeneratedField::ActorSplits => {
9897                            if actor_splits__.is_some() {
9898                                return Err(serde::de::Error::duplicate_field("actorSplits"));
9899                            }
9900                            actor_splits__ = Some(
9901                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9902                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
9903                            );
9904                        }
9905                    }
9906                }
9907                Ok(SourceChangeSplitMutation {
9908                    actor_splits: actor_splits__.unwrap_or_default(),
9909                })
9910            }
9911        }
9912        deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9913    }
9914}
9915impl serde::Serialize for SourceNode {
9916    #[allow(deprecated)]
9917    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9918    where
9919        S: serde::Serializer,
9920    {
9921        use serde::ser::SerializeStruct;
9922        let mut len = 0;
9923        if self.source_inner.is_some() {
9924            len += 1;
9925        }
9926        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9927        if let Some(v) = self.source_inner.as_ref() {
9928            struct_ser.serialize_field("sourceInner", v)?;
9929        }
9930        struct_ser.end()
9931    }
9932}
9933impl<'de> serde::Deserialize<'de> for SourceNode {
9934    #[allow(deprecated)]
9935    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9936    where
9937        D: serde::Deserializer<'de>,
9938    {
9939        const FIELDS: &[&str] = &[
9940            "source_inner",
9941            "sourceInner",
9942        ];
9943
9944        #[allow(clippy::enum_variant_names)]
9945        enum GeneratedField {
9946            SourceInner,
9947        }
9948        impl<'de> serde::Deserialize<'de> for GeneratedField {
9949            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9950            where
9951                D: serde::Deserializer<'de>,
9952            {
9953                struct GeneratedVisitor;
9954
9955                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9956                    type Value = GeneratedField;
9957
9958                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9959                        write!(formatter, "expected one of: {:?}", &FIELDS)
9960                    }
9961
9962                    #[allow(unused_variables)]
9963                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9964                    where
9965                        E: serde::de::Error,
9966                    {
9967                        match value {
9968                            "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9969                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9970                        }
9971                    }
9972                }
9973                deserializer.deserialize_identifier(GeneratedVisitor)
9974            }
9975        }
9976        struct GeneratedVisitor;
9977        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9978            type Value = SourceNode;
9979
9980            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9981                formatter.write_str("struct stream_plan.SourceNode")
9982            }
9983
9984            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9985                where
9986                    V: serde::de::MapAccess<'de>,
9987            {
9988                let mut source_inner__ = None;
9989                while let Some(k) = map_.next_key()? {
9990                    match k {
9991                        GeneratedField::SourceInner => {
9992                            if source_inner__.is_some() {
9993                                return Err(serde::de::Error::duplicate_field("sourceInner"));
9994                            }
9995                            source_inner__ = map_.next_value()?;
9996                        }
9997                    }
9998                }
9999                Ok(SourceNode {
10000                    source_inner: source_inner__,
10001                })
10002            }
10003        }
10004        deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
10005    }
10006}
10007impl serde::Serialize for StartFragmentBackfillMutation {
10008    #[allow(deprecated)]
10009    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10010    where
10011        S: serde::Serializer,
10012    {
10013        use serde::ser::SerializeStruct;
10014        let mut len = 0;
10015        if !self.fragment_ids.is_empty() {
10016            len += 1;
10017        }
10018        let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
10019        if !self.fragment_ids.is_empty() {
10020            struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
10021        }
10022        struct_ser.end()
10023    }
10024}
10025impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
10026    #[allow(deprecated)]
10027    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10028    where
10029        D: serde::Deserializer<'de>,
10030    {
10031        const FIELDS: &[&str] = &[
10032            "fragment_ids",
10033            "fragmentIds",
10034        ];
10035
10036        #[allow(clippy::enum_variant_names)]
10037        enum GeneratedField {
10038            FragmentIds,
10039        }
10040        impl<'de> serde::Deserialize<'de> for GeneratedField {
10041            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10042            where
10043                D: serde::Deserializer<'de>,
10044            {
10045                struct GeneratedVisitor;
10046
10047                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10048                    type Value = GeneratedField;
10049
10050                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10051                        write!(formatter, "expected one of: {:?}", &FIELDS)
10052                    }
10053
10054                    #[allow(unused_variables)]
10055                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10056                    where
10057                        E: serde::de::Error,
10058                    {
10059                        match value {
10060                            "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10061                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10062                        }
10063                    }
10064                }
10065                deserializer.deserialize_identifier(GeneratedVisitor)
10066            }
10067        }
10068        struct GeneratedVisitor;
10069        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10070            type Value = StartFragmentBackfillMutation;
10071
10072            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10073                formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10074            }
10075
10076            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10077                where
10078                    V: serde::de::MapAccess<'de>,
10079            {
10080                let mut fragment_ids__ = None;
10081                while let Some(k) = map_.next_key()? {
10082                    match k {
10083                        GeneratedField::FragmentIds => {
10084                            if fragment_ids__.is_some() {
10085                                return Err(serde::de::Error::duplicate_field("fragmentIds"));
10086                            }
10087                            fragment_ids__ = 
10088                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10089                                    .into_iter().map(|x| x.0).collect())
10090                            ;
10091                        }
10092                    }
10093                }
10094                Ok(StartFragmentBackfillMutation {
10095                    fragment_ids: fragment_ids__.unwrap_or_default(),
10096                })
10097            }
10098        }
10099        deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10100    }
10101}
10102impl serde::Serialize for StopMutation {
10103    #[allow(deprecated)]
10104    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10105    where
10106        S: serde::Serializer,
10107    {
10108        use serde::ser::SerializeStruct;
10109        let mut len = 0;
10110        if !self.actors.is_empty() {
10111            len += 1;
10112        }
10113        if !self.dropped_sink_fragments.is_empty() {
10114            len += 1;
10115        }
10116        let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10117        if !self.actors.is_empty() {
10118            struct_ser.serialize_field("actors", &self.actors)?;
10119        }
10120        if !self.dropped_sink_fragments.is_empty() {
10121            struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10122        }
10123        struct_ser.end()
10124    }
10125}
10126impl<'de> serde::Deserialize<'de> for StopMutation {
10127    #[allow(deprecated)]
10128    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10129    where
10130        D: serde::Deserializer<'de>,
10131    {
10132        const FIELDS: &[&str] = &[
10133            "actors",
10134            "dropped_sink_fragments",
10135            "droppedSinkFragments",
10136        ];
10137
10138        #[allow(clippy::enum_variant_names)]
10139        enum GeneratedField {
10140            Actors,
10141            DroppedSinkFragments,
10142        }
10143        impl<'de> serde::Deserialize<'de> for GeneratedField {
10144            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10145            where
10146                D: serde::Deserializer<'de>,
10147            {
10148                struct GeneratedVisitor;
10149
10150                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10151                    type Value = GeneratedField;
10152
10153                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10154                        write!(formatter, "expected one of: {:?}", &FIELDS)
10155                    }
10156
10157                    #[allow(unused_variables)]
10158                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10159                    where
10160                        E: serde::de::Error,
10161                    {
10162                        match value {
10163                            "actors" => Ok(GeneratedField::Actors),
10164                            "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10165                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10166                        }
10167                    }
10168                }
10169                deserializer.deserialize_identifier(GeneratedVisitor)
10170            }
10171        }
10172        struct GeneratedVisitor;
10173        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10174            type Value = StopMutation;
10175
10176            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10177                formatter.write_str("struct stream_plan.StopMutation")
10178            }
10179
10180            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10181                where
10182                    V: serde::de::MapAccess<'de>,
10183            {
10184                let mut actors__ = None;
10185                let mut dropped_sink_fragments__ = None;
10186                while let Some(k) = map_.next_key()? {
10187                    match k {
10188                        GeneratedField::Actors => {
10189                            if actors__.is_some() {
10190                                return Err(serde::de::Error::duplicate_field("actors"));
10191                            }
10192                            actors__ = 
10193                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10194                                    .into_iter().map(|x| x.0).collect())
10195                            ;
10196                        }
10197                        GeneratedField::DroppedSinkFragments => {
10198                            if dropped_sink_fragments__.is_some() {
10199                                return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10200                            }
10201                            dropped_sink_fragments__ = 
10202                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10203                                    .into_iter().map(|x| x.0).collect())
10204                            ;
10205                        }
10206                    }
10207                }
10208                Ok(StopMutation {
10209                    actors: actors__.unwrap_or_default(),
10210                    dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10211                })
10212            }
10213        }
10214        deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10215    }
10216}
10217impl serde::Serialize for StreamActor {
10218    #[allow(deprecated)]
10219    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10220    where
10221        S: serde::Serializer,
10222    {
10223        use serde::ser::SerializeStruct;
10224        let mut len = 0;
10225        if self.actor_id != 0 {
10226            len += 1;
10227        }
10228        if self.fragment_id != 0 {
10229            len += 1;
10230        }
10231        if !self.dispatcher.is_empty() {
10232            len += 1;
10233        }
10234        if self.vnode_bitmap.is_some() {
10235            len += 1;
10236        }
10237        if !self.mview_definition.is_empty() {
10238            len += 1;
10239        }
10240        if self.expr_context.is_some() {
10241            len += 1;
10242        }
10243        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10244        if self.actor_id != 0 {
10245            struct_ser.serialize_field("actorId", &self.actor_id)?;
10246        }
10247        if self.fragment_id != 0 {
10248            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10249        }
10250        if !self.dispatcher.is_empty() {
10251            struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10252        }
10253        if let Some(v) = self.vnode_bitmap.as_ref() {
10254            struct_ser.serialize_field("vnodeBitmap", v)?;
10255        }
10256        if !self.mview_definition.is_empty() {
10257            struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10258        }
10259        if let Some(v) = self.expr_context.as_ref() {
10260            struct_ser.serialize_field("exprContext", v)?;
10261        }
10262        struct_ser.end()
10263    }
10264}
10265impl<'de> serde::Deserialize<'de> for StreamActor {
10266    #[allow(deprecated)]
10267    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10268    where
10269        D: serde::Deserializer<'de>,
10270    {
10271        const FIELDS: &[&str] = &[
10272            "actor_id",
10273            "actorId",
10274            "fragment_id",
10275            "fragmentId",
10276            "dispatcher",
10277            "vnode_bitmap",
10278            "vnodeBitmap",
10279            "mview_definition",
10280            "mviewDefinition",
10281            "expr_context",
10282            "exprContext",
10283        ];
10284
10285        #[allow(clippy::enum_variant_names)]
10286        enum GeneratedField {
10287            ActorId,
10288            FragmentId,
10289            Dispatcher,
10290            VnodeBitmap,
10291            MviewDefinition,
10292            ExprContext,
10293        }
10294        impl<'de> serde::Deserialize<'de> for GeneratedField {
10295            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10296            where
10297                D: serde::Deserializer<'de>,
10298            {
10299                struct GeneratedVisitor;
10300
10301                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10302                    type Value = GeneratedField;
10303
10304                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10305                        write!(formatter, "expected one of: {:?}", &FIELDS)
10306                    }
10307
10308                    #[allow(unused_variables)]
10309                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10310                    where
10311                        E: serde::de::Error,
10312                    {
10313                        match value {
10314                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10315                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10316                            "dispatcher" => Ok(GeneratedField::Dispatcher),
10317                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10318                            "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10319                            "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10320                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10321                        }
10322                    }
10323                }
10324                deserializer.deserialize_identifier(GeneratedVisitor)
10325            }
10326        }
10327        struct GeneratedVisitor;
10328        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10329            type Value = StreamActor;
10330
10331            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10332                formatter.write_str("struct stream_plan.StreamActor")
10333            }
10334
10335            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10336                where
10337                    V: serde::de::MapAccess<'de>,
10338            {
10339                let mut actor_id__ = None;
10340                let mut fragment_id__ = None;
10341                let mut dispatcher__ = None;
10342                let mut vnode_bitmap__ = None;
10343                let mut mview_definition__ = None;
10344                let mut expr_context__ = None;
10345                while let Some(k) = map_.next_key()? {
10346                    match k {
10347                        GeneratedField::ActorId => {
10348                            if actor_id__.is_some() {
10349                                return Err(serde::de::Error::duplicate_field("actorId"));
10350                            }
10351                            actor_id__ = 
10352                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10353                            ;
10354                        }
10355                        GeneratedField::FragmentId => {
10356                            if fragment_id__.is_some() {
10357                                return Err(serde::de::Error::duplicate_field("fragmentId"));
10358                            }
10359                            fragment_id__ = 
10360                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10361                            ;
10362                        }
10363                        GeneratedField::Dispatcher => {
10364                            if dispatcher__.is_some() {
10365                                return Err(serde::de::Error::duplicate_field("dispatcher"));
10366                            }
10367                            dispatcher__ = Some(map_.next_value()?);
10368                        }
10369                        GeneratedField::VnodeBitmap => {
10370                            if vnode_bitmap__.is_some() {
10371                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10372                            }
10373                            vnode_bitmap__ = map_.next_value()?;
10374                        }
10375                        GeneratedField::MviewDefinition => {
10376                            if mview_definition__.is_some() {
10377                                return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10378                            }
10379                            mview_definition__ = Some(map_.next_value()?);
10380                        }
10381                        GeneratedField::ExprContext => {
10382                            if expr_context__.is_some() {
10383                                return Err(serde::de::Error::duplicate_field("exprContext"));
10384                            }
10385                            expr_context__ = map_.next_value()?;
10386                        }
10387                    }
10388                }
10389                Ok(StreamActor {
10390                    actor_id: actor_id__.unwrap_or_default(),
10391                    fragment_id: fragment_id__.unwrap_or_default(),
10392                    dispatcher: dispatcher__.unwrap_or_default(),
10393                    vnode_bitmap: vnode_bitmap__,
10394                    mview_definition: mview_definition__.unwrap_or_default(),
10395                    expr_context: expr_context__,
10396                })
10397            }
10398        }
10399        deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10400    }
10401}
10402impl serde::Serialize for StreamCdcScanNode {
10403    #[allow(deprecated)]
10404    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10405    where
10406        S: serde::Serializer,
10407    {
10408        use serde::ser::SerializeStruct;
10409        let mut len = 0;
10410        if self.table_id != 0 {
10411            len += 1;
10412        }
10413        if !self.upstream_column_ids.is_empty() {
10414            len += 1;
10415        }
10416        if !self.output_indices.is_empty() {
10417            len += 1;
10418        }
10419        if self.state_table.is_some() {
10420            len += 1;
10421        }
10422        if self.cdc_table_desc.is_some() {
10423            len += 1;
10424        }
10425        if self.rate_limit.is_some() {
10426            len += 1;
10427        }
10428        if self.disable_backfill {
10429            len += 1;
10430        }
10431        if self.options.is_some() {
10432            len += 1;
10433        }
10434        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
10435        if self.table_id != 0 {
10436            struct_ser.serialize_field("tableId", &self.table_id)?;
10437        }
10438        if !self.upstream_column_ids.is_empty() {
10439            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
10440        }
10441        if !self.output_indices.is_empty() {
10442            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
10443        }
10444        if let Some(v) = self.state_table.as_ref() {
10445            struct_ser.serialize_field("stateTable", v)?;
10446        }
10447        if let Some(v) = self.cdc_table_desc.as_ref() {
10448            struct_ser.serialize_field("cdcTableDesc", v)?;
10449        }
10450        if let Some(v) = self.rate_limit.as_ref() {
10451            struct_ser.serialize_field("rateLimit", v)?;
10452        }
10453        if self.disable_backfill {
10454            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10455        }
10456        if let Some(v) = self.options.as_ref() {
10457            struct_ser.serialize_field("options", v)?;
10458        }
10459        struct_ser.end()
10460    }
10461}
10462impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
10463    #[allow(deprecated)]
10464    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10465    where
10466        D: serde::Deserializer<'de>,
10467    {
10468        const FIELDS: &[&str] = &[
10469            "table_id",
10470            "tableId",
10471            "upstream_column_ids",
10472            "upstreamColumnIds",
10473            "output_indices",
10474            "outputIndices",
10475            "state_table",
10476            "stateTable",
10477            "cdc_table_desc",
10478            "cdcTableDesc",
10479            "rate_limit",
10480            "rateLimit",
10481            "disable_backfill",
10482            "disableBackfill",
10483            "options",
10484        ];
10485
10486        #[allow(clippy::enum_variant_names)]
10487        enum GeneratedField {
10488            TableId,
10489            UpstreamColumnIds,
10490            OutputIndices,
10491            StateTable,
10492            CdcTableDesc,
10493            RateLimit,
10494            DisableBackfill,
10495            Options,
10496        }
10497        impl<'de> serde::Deserialize<'de> for GeneratedField {
10498            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10499            where
10500                D: serde::Deserializer<'de>,
10501            {
10502                struct GeneratedVisitor;
10503
10504                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10505                    type Value = GeneratedField;
10506
10507                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10508                        write!(formatter, "expected one of: {:?}", &FIELDS)
10509                    }
10510
10511                    #[allow(unused_variables)]
10512                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10513                    where
10514                        E: serde::de::Error,
10515                    {
10516                        match value {
10517                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
10518                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
10519                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
10520                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10521                            "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
10522                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10523                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10524                            "options" => Ok(GeneratedField::Options),
10525                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10526                        }
10527                    }
10528                }
10529                deserializer.deserialize_identifier(GeneratedVisitor)
10530            }
10531        }
10532        struct GeneratedVisitor;
10533        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10534            type Value = StreamCdcScanNode;
10535
10536            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10537                formatter.write_str("struct stream_plan.StreamCdcScanNode")
10538            }
10539
10540            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10541                where
10542                    V: serde::de::MapAccess<'de>,
10543            {
10544                let mut table_id__ = None;
10545                let mut upstream_column_ids__ = None;
10546                let mut output_indices__ = None;
10547                let mut state_table__ = None;
10548                let mut cdc_table_desc__ = None;
10549                let mut rate_limit__ = None;
10550                let mut disable_backfill__ = None;
10551                let mut options__ = None;
10552                while let Some(k) = map_.next_key()? {
10553                    match k {
10554                        GeneratedField::TableId => {
10555                            if table_id__.is_some() {
10556                                return Err(serde::de::Error::duplicate_field("tableId"));
10557                            }
10558                            table_id__ = 
10559                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10560                            ;
10561                        }
10562                        GeneratedField::UpstreamColumnIds => {
10563                            if upstream_column_ids__.is_some() {
10564                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10565                            }
10566                            upstream_column_ids__ = 
10567                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10568                                    .into_iter().map(|x| x.0).collect())
10569                            ;
10570                        }
10571                        GeneratedField::OutputIndices => {
10572                            if output_indices__.is_some() {
10573                                return Err(serde::de::Error::duplicate_field("outputIndices"));
10574                            }
10575                            output_indices__ = 
10576                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10577                                    .into_iter().map(|x| x.0).collect())
10578                            ;
10579                        }
10580                        GeneratedField::StateTable => {
10581                            if state_table__.is_some() {
10582                                return Err(serde::de::Error::duplicate_field("stateTable"));
10583                            }
10584                            state_table__ = map_.next_value()?;
10585                        }
10586                        GeneratedField::CdcTableDesc => {
10587                            if cdc_table_desc__.is_some() {
10588                                return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10589                            }
10590                            cdc_table_desc__ = map_.next_value()?;
10591                        }
10592                        GeneratedField::RateLimit => {
10593                            if rate_limit__.is_some() {
10594                                return Err(serde::de::Error::duplicate_field("rateLimit"));
10595                            }
10596                            rate_limit__ = 
10597                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10598                            ;
10599                        }
10600                        GeneratedField::DisableBackfill => {
10601                            if disable_backfill__.is_some() {
10602                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10603                            }
10604                            disable_backfill__ = Some(map_.next_value()?);
10605                        }
10606                        GeneratedField::Options => {
10607                            if options__.is_some() {
10608                                return Err(serde::de::Error::duplicate_field("options"));
10609                            }
10610                            options__ = map_.next_value()?;
10611                        }
10612                    }
10613                }
10614                Ok(StreamCdcScanNode {
10615                    table_id: table_id__.unwrap_or_default(),
10616                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10617                    output_indices: output_indices__.unwrap_or_default(),
10618                    state_table: state_table__,
10619                    cdc_table_desc: cdc_table_desc__,
10620                    rate_limit: rate_limit__,
10621                    disable_backfill: disable_backfill__.unwrap_or_default(),
10622                    options: options__,
10623                })
10624            }
10625        }
10626        deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10627    }
10628}
10629impl serde::Serialize for StreamCdcScanOptions {
10630    #[allow(deprecated)]
10631    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10632    where
10633        S: serde::Serializer,
10634    {
10635        use serde::ser::SerializeStruct;
10636        let mut len = 0;
10637        if self.disable_backfill {
10638            len += 1;
10639        }
10640        if self.snapshot_barrier_interval != 0 {
10641            len += 1;
10642        }
10643        if self.snapshot_batch_size != 0 {
10644            len += 1;
10645        }
10646        if self.backfill_parallelism != 0 {
10647            len += 1;
10648        }
10649        if self.backfill_num_rows_per_split != 0 {
10650            len += 1;
10651        }
10652        if self.backfill_as_even_splits {
10653            len += 1;
10654        }
10655        if self.backfill_split_pk_column_index != 0 {
10656            len += 1;
10657        }
10658        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10659        if self.disable_backfill {
10660            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10661        }
10662        if self.snapshot_barrier_interval != 0 {
10663            struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10664        }
10665        if self.snapshot_batch_size != 0 {
10666            struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10667        }
10668        if self.backfill_parallelism != 0 {
10669            struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
10670        }
10671        if self.backfill_num_rows_per_split != 0 {
10672            #[allow(clippy::needless_borrow)]
10673            #[allow(clippy::needless_borrows_for_generic_args)]
10674            struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
10675        }
10676        if self.backfill_as_even_splits {
10677            struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
10678        }
10679        if self.backfill_split_pk_column_index != 0 {
10680            struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
10681        }
10682        struct_ser.end()
10683    }
10684}
10685impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10686    #[allow(deprecated)]
10687    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10688    where
10689        D: serde::Deserializer<'de>,
10690    {
10691        const FIELDS: &[&str] = &[
10692            "disable_backfill",
10693            "disableBackfill",
10694            "snapshot_barrier_interval",
10695            "snapshotBarrierInterval",
10696            "snapshot_batch_size",
10697            "snapshotBatchSize",
10698            "backfill_parallelism",
10699            "backfillParallelism",
10700            "backfill_num_rows_per_split",
10701            "backfillNumRowsPerSplit",
10702            "backfill_as_even_splits",
10703            "backfillAsEvenSplits",
10704            "backfill_split_pk_column_index",
10705            "backfillSplitPkColumnIndex",
10706        ];
10707
10708        #[allow(clippy::enum_variant_names)]
10709        enum GeneratedField {
10710            DisableBackfill,
10711            SnapshotBarrierInterval,
10712            SnapshotBatchSize,
10713            BackfillParallelism,
10714            BackfillNumRowsPerSplit,
10715            BackfillAsEvenSplits,
10716            BackfillSplitPkColumnIndex,
10717        }
10718        impl<'de> serde::Deserialize<'de> for GeneratedField {
10719            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10720            where
10721                D: serde::Deserializer<'de>,
10722            {
10723                struct GeneratedVisitor;
10724
10725                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10726                    type Value = GeneratedField;
10727
10728                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10729                        write!(formatter, "expected one of: {:?}", &FIELDS)
10730                    }
10731
10732                    #[allow(unused_variables)]
10733                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10734                    where
10735                        E: serde::de::Error,
10736                    {
10737                        match value {
10738                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10739                            "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10740                            "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10741                            "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
10742                            "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
10743                            "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
10744                            "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
10745                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10746                        }
10747                    }
10748                }
10749                deserializer.deserialize_identifier(GeneratedVisitor)
10750            }
10751        }
10752        struct GeneratedVisitor;
10753        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10754            type Value = StreamCdcScanOptions;
10755
10756            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10757                formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10758            }
10759
10760            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10761                where
10762                    V: serde::de::MapAccess<'de>,
10763            {
10764                let mut disable_backfill__ = None;
10765                let mut snapshot_barrier_interval__ = None;
10766                let mut snapshot_batch_size__ = None;
10767                let mut backfill_parallelism__ = None;
10768                let mut backfill_num_rows_per_split__ = None;
10769                let mut backfill_as_even_splits__ = None;
10770                let mut backfill_split_pk_column_index__ = None;
10771                while let Some(k) = map_.next_key()? {
10772                    match k {
10773                        GeneratedField::DisableBackfill => {
10774                            if disable_backfill__.is_some() {
10775                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10776                            }
10777                            disable_backfill__ = Some(map_.next_value()?);
10778                        }
10779                        GeneratedField::SnapshotBarrierInterval => {
10780                            if snapshot_barrier_interval__.is_some() {
10781                                return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10782                            }
10783                            snapshot_barrier_interval__ = 
10784                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10785                            ;
10786                        }
10787                        GeneratedField::SnapshotBatchSize => {
10788                            if snapshot_batch_size__.is_some() {
10789                                return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10790                            }
10791                            snapshot_batch_size__ = 
10792                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10793                            ;
10794                        }
10795                        GeneratedField::BackfillParallelism => {
10796                            if backfill_parallelism__.is_some() {
10797                                return Err(serde::de::Error::duplicate_field("backfillParallelism"));
10798                            }
10799                            backfill_parallelism__ = 
10800                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10801                            ;
10802                        }
10803                        GeneratedField::BackfillNumRowsPerSplit => {
10804                            if backfill_num_rows_per_split__.is_some() {
10805                                return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
10806                            }
10807                            backfill_num_rows_per_split__ = 
10808                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10809                            ;
10810                        }
10811                        GeneratedField::BackfillAsEvenSplits => {
10812                            if backfill_as_even_splits__.is_some() {
10813                                return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
10814                            }
10815                            backfill_as_even_splits__ = Some(map_.next_value()?);
10816                        }
10817                        GeneratedField::BackfillSplitPkColumnIndex => {
10818                            if backfill_split_pk_column_index__.is_some() {
10819                                return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
10820                            }
10821                            backfill_split_pk_column_index__ = 
10822                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10823                            ;
10824                        }
10825                    }
10826                }
10827                Ok(StreamCdcScanOptions {
10828                    disable_backfill: disable_backfill__.unwrap_or_default(),
10829                    snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10830                    snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10831                    backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
10832                    backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
10833                    backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
10834                    backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
10835                })
10836            }
10837        }
10838        deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10839    }
10840}
10841impl serde::Serialize for StreamContext {
10842    #[allow(deprecated)]
10843    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10844    where
10845        S: serde::Serializer,
10846    {
10847        use serde::ser::SerializeStruct;
10848        let mut len = 0;
10849        if !self.timezone.is_empty() {
10850            len += 1;
10851        }
10852        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10853        if !self.timezone.is_empty() {
10854            struct_ser.serialize_field("timezone", &self.timezone)?;
10855        }
10856        struct_ser.end()
10857    }
10858}
10859impl<'de> serde::Deserialize<'de> for StreamContext {
10860    #[allow(deprecated)]
10861    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10862    where
10863        D: serde::Deserializer<'de>,
10864    {
10865        const FIELDS: &[&str] = &[
10866            "timezone",
10867        ];
10868
10869        #[allow(clippy::enum_variant_names)]
10870        enum GeneratedField {
10871            Timezone,
10872        }
10873        impl<'de> serde::Deserialize<'de> for GeneratedField {
10874            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10875            where
10876                D: serde::Deserializer<'de>,
10877            {
10878                struct GeneratedVisitor;
10879
10880                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10881                    type Value = GeneratedField;
10882
10883                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10884                        write!(formatter, "expected one of: {:?}", &FIELDS)
10885                    }
10886
10887                    #[allow(unused_variables)]
10888                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10889                    where
10890                        E: serde::de::Error,
10891                    {
10892                        match value {
10893                            "timezone" => Ok(GeneratedField::Timezone),
10894                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10895                        }
10896                    }
10897                }
10898                deserializer.deserialize_identifier(GeneratedVisitor)
10899            }
10900        }
10901        struct GeneratedVisitor;
10902        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10903            type Value = StreamContext;
10904
10905            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10906                formatter.write_str("struct stream_plan.StreamContext")
10907            }
10908
10909            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10910                where
10911                    V: serde::de::MapAccess<'de>,
10912            {
10913                let mut timezone__ = None;
10914                while let Some(k) = map_.next_key()? {
10915                    match k {
10916                        GeneratedField::Timezone => {
10917                            if timezone__.is_some() {
10918                                return Err(serde::de::Error::duplicate_field("timezone"));
10919                            }
10920                            timezone__ = Some(map_.next_value()?);
10921                        }
10922                    }
10923                }
10924                Ok(StreamContext {
10925                    timezone: timezone__.unwrap_or_default(),
10926                })
10927            }
10928        }
10929        deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10930    }
10931}
10932impl serde::Serialize for StreamFragmentGraph {
10933    #[allow(deprecated)]
10934    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10935    where
10936        S: serde::Serializer,
10937    {
10938        use serde::ser::SerializeStruct;
10939        let mut len = 0;
10940        if !self.fragments.is_empty() {
10941            len += 1;
10942        }
10943        if !self.edges.is_empty() {
10944            len += 1;
10945        }
10946        if !self.dependent_table_ids.is_empty() {
10947            len += 1;
10948        }
10949        if self.table_ids_cnt != 0 {
10950            len += 1;
10951        }
10952        if self.ctx.is_some() {
10953            len += 1;
10954        }
10955        if self.parallelism.is_some() {
10956            len += 1;
10957        }
10958        if self.max_parallelism != 0 {
10959            len += 1;
10960        }
10961        if self.backfill_order.is_some() {
10962            len += 1;
10963        }
10964        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10965        if !self.fragments.is_empty() {
10966            struct_ser.serialize_field("fragments", &self.fragments)?;
10967        }
10968        if !self.edges.is_empty() {
10969            struct_ser.serialize_field("edges", &self.edges)?;
10970        }
10971        if !self.dependent_table_ids.is_empty() {
10972            struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10973        }
10974        if self.table_ids_cnt != 0 {
10975            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10976        }
10977        if let Some(v) = self.ctx.as_ref() {
10978            struct_ser.serialize_field("ctx", v)?;
10979        }
10980        if let Some(v) = self.parallelism.as_ref() {
10981            struct_ser.serialize_field("parallelism", v)?;
10982        }
10983        if self.max_parallelism != 0 {
10984            struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10985        }
10986        if let Some(v) = self.backfill_order.as_ref() {
10987            struct_ser.serialize_field("backfillOrder", v)?;
10988        }
10989        struct_ser.end()
10990    }
10991}
10992impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10993    #[allow(deprecated)]
10994    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10995    where
10996        D: serde::Deserializer<'de>,
10997    {
10998        const FIELDS: &[&str] = &[
10999            "fragments",
11000            "edges",
11001            "dependent_table_ids",
11002            "dependentTableIds",
11003            "table_ids_cnt",
11004            "tableIdsCnt",
11005            "ctx",
11006            "parallelism",
11007            "max_parallelism",
11008            "maxParallelism",
11009            "backfill_order",
11010            "backfillOrder",
11011        ];
11012
11013        #[allow(clippy::enum_variant_names)]
11014        enum GeneratedField {
11015            Fragments,
11016            Edges,
11017            DependentTableIds,
11018            TableIdsCnt,
11019            Ctx,
11020            Parallelism,
11021            MaxParallelism,
11022            BackfillOrder,
11023        }
11024        impl<'de> serde::Deserialize<'de> for GeneratedField {
11025            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11026            where
11027                D: serde::Deserializer<'de>,
11028            {
11029                struct GeneratedVisitor;
11030
11031                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11032                    type Value = GeneratedField;
11033
11034                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11035                        write!(formatter, "expected one of: {:?}", &FIELDS)
11036                    }
11037
11038                    #[allow(unused_variables)]
11039                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11040                    where
11041                        E: serde::de::Error,
11042                    {
11043                        match value {
11044                            "fragments" => Ok(GeneratedField::Fragments),
11045                            "edges" => Ok(GeneratedField::Edges),
11046                            "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
11047                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11048                            "ctx" => Ok(GeneratedField::Ctx),
11049                            "parallelism" => Ok(GeneratedField::Parallelism),
11050                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11051                            "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
11052                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11053                        }
11054                    }
11055                }
11056                deserializer.deserialize_identifier(GeneratedVisitor)
11057            }
11058        }
11059        struct GeneratedVisitor;
11060        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11061            type Value = StreamFragmentGraph;
11062
11063            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11064                formatter.write_str("struct stream_plan.StreamFragmentGraph")
11065            }
11066
11067            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11068                where
11069                    V: serde::de::MapAccess<'de>,
11070            {
11071                let mut fragments__ = None;
11072                let mut edges__ = None;
11073                let mut dependent_table_ids__ = None;
11074                let mut table_ids_cnt__ = None;
11075                let mut ctx__ = None;
11076                let mut parallelism__ = None;
11077                let mut max_parallelism__ = None;
11078                let mut backfill_order__ = None;
11079                while let Some(k) = map_.next_key()? {
11080                    match k {
11081                        GeneratedField::Fragments => {
11082                            if fragments__.is_some() {
11083                                return Err(serde::de::Error::duplicate_field("fragments"));
11084                            }
11085                            fragments__ = Some(
11086                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11087                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
11088                            );
11089                        }
11090                        GeneratedField::Edges => {
11091                            if edges__.is_some() {
11092                                return Err(serde::de::Error::duplicate_field("edges"));
11093                            }
11094                            edges__ = Some(map_.next_value()?);
11095                        }
11096                        GeneratedField::DependentTableIds => {
11097                            if dependent_table_ids__.is_some() {
11098                                return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11099                            }
11100                            dependent_table_ids__ = 
11101                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11102                                    .into_iter().map(|x| x.0).collect())
11103                            ;
11104                        }
11105                        GeneratedField::TableIdsCnt => {
11106                            if table_ids_cnt__.is_some() {
11107                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11108                            }
11109                            table_ids_cnt__ = 
11110                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11111                            ;
11112                        }
11113                        GeneratedField::Ctx => {
11114                            if ctx__.is_some() {
11115                                return Err(serde::de::Error::duplicate_field("ctx"));
11116                            }
11117                            ctx__ = map_.next_value()?;
11118                        }
11119                        GeneratedField::Parallelism => {
11120                            if parallelism__.is_some() {
11121                                return Err(serde::de::Error::duplicate_field("parallelism"));
11122                            }
11123                            parallelism__ = map_.next_value()?;
11124                        }
11125                        GeneratedField::MaxParallelism => {
11126                            if max_parallelism__.is_some() {
11127                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
11128                            }
11129                            max_parallelism__ = 
11130                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11131                            ;
11132                        }
11133                        GeneratedField::BackfillOrder => {
11134                            if backfill_order__.is_some() {
11135                                return Err(serde::de::Error::duplicate_field("backfillOrder"));
11136                            }
11137                            backfill_order__ = map_.next_value()?;
11138                        }
11139                    }
11140                }
11141                Ok(StreamFragmentGraph {
11142                    fragments: fragments__.unwrap_or_default(),
11143                    edges: edges__.unwrap_or_default(),
11144                    dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11145                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11146                    ctx: ctx__,
11147                    parallelism: parallelism__,
11148                    max_parallelism: max_parallelism__.unwrap_or_default(),
11149                    backfill_order: backfill_order__,
11150                })
11151            }
11152        }
11153        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11154    }
11155}
11156impl serde::Serialize for stream_fragment_graph::Parallelism {
11157    #[allow(deprecated)]
11158    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11159    where
11160        S: serde::Serializer,
11161    {
11162        use serde::ser::SerializeStruct;
11163        let mut len = 0;
11164        if self.parallelism != 0 {
11165            len += 1;
11166        }
11167        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11168        if self.parallelism != 0 {
11169            #[allow(clippy::needless_borrow)]
11170            #[allow(clippy::needless_borrows_for_generic_args)]
11171            struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11172        }
11173        struct_ser.end()
11174    }
11175}
11176impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11177    #[allow(deprecated)]
11178    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11179    where
11180        D: serde::Deserializer<'de>,
11181    {
11182        const FIELDS: &[&str] = &[
11183            "parallelism",
11184        ];
11185
11186        #[allow(clippy::enum_variant_names)]
11187        enum GeneratedField {
11188            Parallelism,
11189        }
11190        impl<'de> serde::Deserialize<'de> for GeneratedField {
11191            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11192            where
11193                D: serde::Deserializer<'de>,
11194            {
11195                struct GeneratedVisitor;
11196
11197                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11198                    type Value = GeneratedField;
11199
11200                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11201                        write!(formatter, "expected one of: {:?}", &FIELDS)
11202                    }
11203
11204                    #[allow(unused_variables)]
11205                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11206                    where
11207                        E: serde::de::Error,
11208                    {
11209                        match value {
11210                            "parallelism" => Ok(GeneratedField::Parallelism),
11211                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11212                        }
11213                    }
11214                }
11215                deserializer.deserialize_identifier(GeneratedVisitor)
11216            }
11217        }
11218        struct GeneratedVisitor;
11219        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11220            type Value = stream_fragment_graph::Parallelism;
11221
11222            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11223                formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11224            }
11225
11226            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11227                where
11228                    V: serde::de::MapAccess<'de>,
11229            {
11230                let mut parallelism__ = None;
11231                while let Some(k) = map_.next_key()? {
11232                    match k {
11233                        GeneratedField::Parallelism => {
11234                            if parallelism__.is_some() {
11235                                return Err(serde::de::Error::duplicate_field("parallelism"));
11236                            }
11237                            parallelism__ = 
11238                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11239                            ;
11240                        }
11241                    }
11242                }
11243                Ok(stream_fragment_graph::Parallelism {
11244                    parallelism: parallelism__.unwrap_or_default(),
11245                })
11246            }
11247        }
11248        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11249    }
11250}
11251impl serde::Serialize for stream_fragment_graph::StreamFragment {
11252    #[allow(deprecated)]
11253    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11254    where
11255        S: serde::Serializer,
11256    {
11257        use serde::ser::SerializeStruct;
11258        let mut len = 0;
11259        if self.fragment_id != 0 {
11260            len += 1;
11261        }
11262        if self.node.is_some() {
11263            len += 1;
11264        }
11265        if self.fragment_type_mask != 0 {
11266            len += 1;
11267        }
11268        if self.requires_singleton {
11269            len += 1;
11270        }
11271        if self.table_ids_cnt != 0 {
11272            len += 1;
11273        }
11274        if !self.upstream_table_ids.is_empty() {
11275            len += 1;
11276        }
11277        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11278        if self.fragment_id != 0 {
11279            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11280        }
11281        if let Some(v) = self.node.as_ref() {
11282            struct_ser.serialize_field("node", v)?;
11283        }
11284        if self.fragment_type_mask != 0 {
11285            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11286        }
11287        if self.requires_singleton {
11288            struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11289        }
11290        if self.table_ids_cnt != 0 {
11291            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11292        }
11293        if !self.upstream_table_ids.is_empty() {
11294            struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
11295        }
11296        struct_ser.end()
11297    }
11298}
11299impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11300    #[allow(deprecated)]
11301    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11302    where
11303        D: serde::Deserializer<'de>,
11304    {
11305        const FIELDS: &[&str] = &[
11306            "fragment_id",
11307            "fragmentId",
11308            "node",
11309            "fragment_type_mask",
11310            "fragmentTypeMask",
11311            "requires_singleton",
11312            "requiresSingleton",
11313            "table_ids_cnt",
11314            "tableIdsCnt",
11315            "upstream_table_ids",
11316            "upstreamTableIds",
11317        ];
11318
11319        #[allow(clippy::enum_variant_names)]
11320        enum GeneratedField {
11321            FragmentId,
11322            Node,
11323            FragmentTypeMask,
11324            RequiresSingleton,
11325            TableIdsCnt,
11326            UpstreamTableIds,
11327        }
11328        impl<'de> serde::Deserialize<'de> for GeneratedField {
11329            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11330            where
11331                D: serde::Deserializer<'de>,
11332            {
11333                struct GeneratedVisitor;
11334
11335                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11336                    type Value = GeneratedField;
11337
11338                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11339                        write!(formatter, "expected one of: {:?}", &FIELDS)
11340                    }
11341
11342                    #[allow(unused_variables)]
11343                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11344                    where
11345                        E: serde::de::Error,
11346                    {
11347                        match value {
11348                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11349                            "node" => Ok(GeneratedField::Node),
11350                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11351                            "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11352                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11353                            "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
11354                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11355                        }
11356                    }
11357                }
11358                deserializer.deserialize_identifier(GeneratedVisitor)
11359            }
11360        }
11361        struct GeneratedVisitor;
11362        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11363            type Value = stream_fragment_graph::StreamFragment;
11364
11365            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11366                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11367            }
11368
11369            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11370                where
11371                    V: serde::de::MapAccess<'de>,
11372            {
11373                let mut fragment_id__ = None;
11374                let mut node__ = None;
11375                let mut fragment_type_mask__ = None;
11376                let mut requires_singleton__ = None;
11377                let mut table_ids_cnt__ = None;
11378                let mut upstream_table_ids__ = None;
11379                while let Some(k) = map_.next_key()? {
11380                    match k {
11381                        GeneratedField::FragmentId => {
11382                            if fragment_id__.is_some() {
11383                                return Err(serde::de::Error::duplicate_field("fragmentId"));
11384                            }
11385                            fragment_id__ = 
11386                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11387                            ;
11388                        }
11389                        GeneratedField::Node => {
11390                            if node__.is_some() {
11391                                return Err(serde::de::Error::duplicate_field("node"));
11392                            }
11393                            node__ = map_.next_value()?;
11394                        }
11395                        GeneratedField::FragmentTypeMask => {
11396                            if fragment_type_mask__.is_some() {
11397                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11398                            }
11399                            fragment_type_mask__ = 
11400                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11401                            ;
11402                        }
11403                        GeneratedField::RequiresSingleton => {
11404                            if requires_singleton__.is_some() {
11405                                return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11406                            }
11407                            requires_singleton__ = Some(map_.next_value()?);
11408                        }
11409                        GeneratedField::TableIdsCnt => {
11410                            if table_ids_cnt__.is_some() {
11411                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11412                            }
11413                            table_ids_cnt__ = 
11414                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11415                            ;
11416                        }
11417                        GeneratedField::UpstreamTableIds => {
11418                            if upstream_table_ids__.is_some() {
11419                                return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
11420                            }
11421                            upstream_table_ids__ = 
11422                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11423                                    .into_iter().map(|x| x.0).collect())
11424                            ;
11425                        }
11426                    }
11427                }
11428                Ok(stream_fragment_graph::StreamFragment {
11429                    fragment_id: fragment_id__.unwrap_or_default(),
11430                    node: node__,
11431                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11432                    requires_singleton: requires_singleton__.unwrap_or_default(),
11433                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11434                    upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
11435                })
11436            }
11437        }
11438        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11439    }
11440}
11441impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11442    #[allow(deprecated)]
11443    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11444    where
11445        S: serde::Serializer,
11446    {
11447        use serde::ser::SerializeStruct;
11448        let mut len = 0;
11449        if self.dispatch_strategy.is_some() {
11450            len += 1;
11451        }
11452        if self.link_id != 0 {
11453            len += 1;
11454        }
11455        if self.upstream_id != 0 {
11456            len += 1;
11457        }
11458        if self.downstream_id != 0 {
11459            len += 1;
11460        }
11461        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
11462        if let Some(v) = self.dispatch_strategy.as_ref() {
11463            struct_ser.serialize_field("dispatchStrategy", v)?;
11464        }
11465        if self.link_id != 0 {
11466            #[allow(clippy::needless_borrow)]
11467            #[allow(clippy::needless_borrows_for_generic_args)]
11468            struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
11469        }
11470        if self.upstream_id != 0 {
11471            struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
11472        }
11473        if self.downstream_id != 0 {
11474            struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
11475        }
11476        struct_ser.end()
11477    }
11478}
11479impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
11480    #[allow(deprecated)]
11481    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11482    where
11483        D: serde::Deserializer<'de>,
11484    {
11485        const FIELDS: &[&str] = &[
11486            "dispatch_strategy",
11487            "dispatchStrategy",
11488            "link_id",
11489            "linkId",
11490            "upstream_id",
11491            "upstreamId",
11492            "downstream_id",
11493            "downstreamId",
11494        ];
11495
11496        #[allow(clippy::enum_variant_names)]
11497        enum GeneratedField {
11498            DispatchStrategy,
11499            LinkId,
11500            UpstreamId,
11501            DownstreamId,
11502        }
11503        impl<'de> serde::Deserialize<'de> for GeneratedField {
11504            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11505            where
11506                D: serde::Deserializer<'de>,
11507            {
11508                struct GeneratedVisitor;
11509
11510                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11511                    type Value = GeneratedField;
11512
11513                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11514                        write!(formatter, "expected one of: {:?}", &FIELDS)
11515                    }
11516
11517                    #[allow(unused_variables)]
11518                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11519                    where
11520                        E: serde::de::Error,
11521                    {
11522                        match value {
11523                            "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
11524                            "linkId" | "link_id" => Ok(GeneratedField::LinkId),
11525                            "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
11526                            "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
11527                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11528                        }
11529                    }
11530                }
11531                deserializer.deserialize_identifier(GeneratedVisitor)
11532            }
11533        }
11534        struct GeneratedVisitor;
11535        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11536            type Value = stream_fragment_graph::StreamFragmentEdge;
11537
11538            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11539                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
11540            }
11541
11542            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
11543                where
11544                    V: serde::de::MapAccess<'de>,
11545            {
11546                let mut dispatch_strategy__ = None;
11547                let mut link_id__ = None;
11548                let mut upstream_id__ = None;
11549                let mut downstream_id__ = None;
11550                while let Some(k) = map_.next_key()? {
11551                    match k {
11552                        GeneratedField::DispatchStrategy => {
11553                            if dispatch_strategy__.is_some() {
11554                                return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
11555                            }
11556                            dispatch_strategy__ = map_.next_value()?;
11557                        }
11558                        GeneratedField::LinkId => {
11559                            if link_id__.is_some() {
11560                                return Err(serde::de::Error::duplicate_field("linkId"));
11561                            }
11562                            link_id__ = 
11563                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11564                            ;
11565                        }
11566                        GeneratedField::UpstreamId => {
11567                            if upstream_id__.is_some() {
11568                                return Err(serde::de::Error::duplicate_field("upstreamId"));
11569                            }
11570                            upstream_id__ = 
11571                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11572                            ;
11573                        }
11574                        GeneratedField::DownstreamId => {
11575                            if downstream_id__.is_some() {
11576                                return Err(serde::de::Error::duplicate_field("downstreamId"));
11577                            }
11578                            downstream_id__ = 
11579                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11580                            ;
11581                        }
11582                    }
11583                }
11584                Ok(stream_fragment_graph::StreamFragmentEdge {
11585                    dispatch_strategy: dispatch_strategy__,
11586                    link_id: link_id__.unwrap_or_default(),
11587                    upstream_id: upstream_id__.unwrap_or_default(),
11588                    downstream_id: downstream_id__.unwrap_or_default(),
11589                })
11590            }
11591        }
11592        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
11593    }
11594}
11595impl serde::Serialize for StreamFsFetch {
11596    #[allow(deprecated)]
11597    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11598    where
11599        S: serde::Serializer,
11600    {
11601        use serde::ser::SerializeStruct;
11602        let mut len = 0;
11603        if self.source_id != 0 {
11604            len += 1;
11605        }
11606        if self.state_table.is_some() {
11607            len += 1;
11608        }
11609        if self.row_id_index.is_some() {
11610            len += 1;
11611        }
11612        if !self.columns.is_empty() {
11613            len += 1;
11614        }
11615        if !self.with_properties.is_empty() {
11616            len += 1;
11617        }
11618        if self.info.is_some() {
11619            len += 1;
11620        }
11621        if !self.source_name.is_empty() {
11622            len += 1;
11623        }
11624        if self.rate_limit.is_some() {
11625            len += 1;
11626        }
11627        if !self.secret_refs.is_empty() {
11628            len += 1;
11629        }
11630        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11631        if self.source_id != 0 {
11632            struct_ser.serialize_field("sourceId", &self.source_id)?;
11633        }
11634        if let Some(v) = self.state_table.as_ref() {
11635            struct_ser.serialize_field("stateTable", v)?;
11636        }
11637        if let Some(v) = self.row_id_index.as_ref() {
11638            struct_ser.serialize_field("rowIdIndex", v)?;
11639        }
11640        if !self.columns.is_empty() {
11641            struct_ser.serialize_field("columns", &self.columns)?;
11642        }
11643        if !self.with_properties.is_empty() {
11644            struct_ser.serialize_field("withProperties", &self.with_properties)?;
11645        }
11646        if let Some(v) = self.info.as_ref() {
11647            struct_ser.serialize_field("info", v)?;
11648        }
11649        if !self.source_name.is_empty() {
11650            struct_ser.serialize_field("sourceName", &self.source_name)?;
11651        }
11652        if let Some(v) = self.rate_limit.as_ref() {
11653            struct_ser.serialize_field("rateLimit", v)?;
11654        }
11655        if !self.secret_refs.is_empty() {
11656            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11657        }
11658        struct_ser.end()
11659    }
11660}
11661impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11662    #[allow(deprecated)]
11663    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11664    where
11665        D: serde::Deserializer<'de>,
11666    {
11667        const FIELDS: &[&str] = &[
11668            "source_id",
11669            "sourceId",
11670            "state_table",
11671            "stateTable",
11672            "row_id_index",
11673            "rowIdIndex",
11674            "columns",
11675            "with_properties",
11676            "withProperties",
11677            "info",
11678            "source_name",
11679            "sourceName",
11680            "rate_limit",
11681            "rateLimit",
11682            "secret_refs",
11683            "secretRefs",
11684        ];
11685
11686        #[allow(clippy::enum_variant_names)]
11687        enum GeneratedField {
11688            SourceId,
11689            StateTable,
11690            RowIdIndex,
11691            Columns,
11692            WithProperties,
11693            Info,
11694            SourceName,
11695            RateLimit,
11696            SecretRefs,
11697        }
11698        impl<'de> serde::Deserialize<'de> for GeneratedField {
11699            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11700            where
11701                D: serde::Deserializer<'de>,
11702            {
11703                struct GeneratedVisitor;
11704
11705                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11706                    type Value = GeneratedField;
11707
11708                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11709                        write!(formatter, "expected one of: {:?}", &FIELDS)
11710                    }
11711
11712                    #[allow(unused_variables)]
11713                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11714                    where
11715                        E: serde::de::Error,
11716                    {
11717                        match value {
11718                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11719                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11720                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11721                            "columns" => Ok(GeneratedField::Columns),
11722                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11723                            "info" => Ok(GeneratedField::Info),
11724                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11725                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11726                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11727                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11728                        }
11729                    }
11730                }
11731                deserializer.deserialize_identifier(GeneratedVisitor)
11732            }
11733        }
11734        struct GeneratedVisitor;
11735        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11736            type Value = StreamFsFetch;
11737
11738            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11739                formatter.write_str("struct stream_plan.StreamFsFetch")
11740            }
11741
11742            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11743                where
11744                    V: serde::de::MapAccess<'de>,
11745            {
11746                let mut source_id__ = None;
11747                let mut state_table__ = None;
11748                let mut row_id_index__ = None;
11749                let mut columns__ = None;
11750                let mut with_properties__ = None;
11751                let mut info__ = None;
11752                let mut source_name__ = None;
11753                let mut rate_limit__ = None;
11754                let mut secret_refs__ = None;
11755                while let Some(k) = map_.next_key()? {
11756                    match k {
11757                        GeneratedField::SourceId => {
11758                            if source_id__.is_some() {
11759                                return Err(serde::de::Error::duplicate_field("sourceId"));
11760                            }
11761                            source_id__ = 
11762                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11763                            ;
11764                        }
11765                        GeneratedField::StateTable => {
11766                            if state_table__.is_some() {
11767                                return Err(serde::de::Error::duplicate_field("stateTable"));
11768                            }
11769                            state_table__ = map_.next_value()?;
11770                        }
11771                        GeneratedField::RowIdIndex => {
11772                            if row_id_index__.is_some() {
11773                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11774                            }
11775                            row_id_index__ = 
11776                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11777                            ;
11778                        }
11779                        GeneratedField::Columns => {
11780                            if columns__.is_some() {
11781                                return Err(serde::de::Error::duplicate_field("columns"));
11782                            }
11783                            columns__ = Some(map_.next_value()?);
11784                        }
11785                        GeneratedField::WithProperties => {
11786                            if with_properties__.is_some() {
11787                                return Err(serde::de::Error::duplicate_field("withProperties"));
11788                            }
11789                            with_properties__ = Some(
11790                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11791                            );
11792                        }
11793                        GeneratedField::Info => {
11794                            if info__.is_some() {
11795                                return Err(serde::de::Error::duplicate_field("info"));
11796                            }
11797                            info__ = map_.next_value()?;
11798                        }
11799                        GeneratedField::SourceName => {
11800                            if source_name__.is_some() {
11801                                return Err(serde::de::Error::duplicate_field("sourceName"));
11802                            }
11803                            source_name__ = Some(map_.next_value()?);
11804                        }
11805                        GeneratedField::RateLimit => {
11806                            if rate_limit__.is_some() {
11807                                return Err(serde::de::Error::duplicate_field("rateLimit"));
11808                            }
11809                            rate_limit__ = 
11810                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11811                            ;
11812                        }
11813                        GeneratedField::SecretRefs => {
11814                            if secret_refs__.is_some() {
11815                                return Err(serde::de::Error::duplicate_field("secretRefs"));
11816                            }
11817                            secret_refs__ = Some(
11818                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11819                            );
11820                        }
11821                    }
11822                }
11823                Ok(StreamFsFetch {
11824                    source_id: source_id__.unwrap_or_default(),
11825                    state_table: state_table__,
11826                    row_id_index: row_id_index__,
11827                    columns: columns__.unwrap_or_default(),
11828                    with_properties: with_properties__.unwrap_or_default(),
11829                    info: info__,
11830                    source_name: source_name__.unwrap_or_default(),
11831                    rate_limit: rate_limit__,
11832                    secret_refs: secret_refs__.unwrap_or_default(),
11833                })
11834            }
11835        }
11836        deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11837    }
11838}
11839impl serde::Serialize for StreamFsFetchNode {
11840    #[allow(deprecated)]
11841    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11842    where
11843        S: serde::Serializer,
11844    {
11845        use serde::ser::SerializeStruct;
11846        let mut len = 0;
11847        if self.node_inner.is_some() {
11848            len += 1;
11849        }
11850        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11851        if let Some(v) = self.node_inner.as_ref() {
11852            struct_ser.serialize_field("nodeInner", v)?;
11853        }
11854        struct_ser.end()
11855    }
11856}
11857impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11858    #[allow(deprecated)]
11859    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11860    where
11861        D: serde::Deserializer<'de>,
11862    {
11863        const FIELDS: &[&str] = &[
11864            "node_inner",
11865            "nodeInner",
11866        ];
11867
11868        #[allow(clippy::enum_variant_names)]
11869        enum GeneratedField {
11870            NodeInner,
11871        }
11872        impl<'de> serde::Deserialize<'de> for GeneratedField {
11873            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11874            where
11875                D: serde::Deserializer<'de>,
11876            {
11877                struct GeneratedVisitor;
11878
11879                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11880                    type Value = GeneratedField;
11881
11882                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11883                        write!(formatter, "expected one of: {:?}", &FIELDS)
11884                    }
11885
11886                    #[allow(unused_variables)]
11887                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11888                    where
11889                        E: serde::de::Error,
11890                    {
11891                        match value {
11892                            "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11893                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11894                        }
11895                    }
11896                }
11897                deserializer.deserialize_identifier(GeneratedVisitor)
11898            }
11899        }
11900        struct GeneratedVisitor;
11901        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11902            type Value = StreamFsFetchNode;
11903
11904            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11905                formatter.write_str("struct stream_plan.StreamFsFetchNode")
11906            }
11907
11908            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11909                where
11910                    V: serde::de::MapAccess<'de>,
11911            {
11912                let mut node_inner__ = None;
11913                while let Some(k) = map_.next_key()? {
11914                    match k {
11915                        GeneratedField::NodeInner => {
11916                            if node_inner__.is_some() {
11917                                return Err(serde::de::Error::duplicate_field("nodeInner"));
11918                            }
11919                            node_inner__ = map_.next_value()?;
11920                        }
11921                    }
11922                }
11923                Ok(StreamFsFetchNode {
11924                    node_inner: node_inner__,
11925                })
11926            }
11927        }
11928        deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11929    }
11930}
11931impl serde::Serialize for StreamMessage {
11932    #[allow(deprecated)]
11933    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11934    where
11935        S: serde::Serializer,
11936    {
11937        use serde::ser::SerializeStruct;
11938        let mut len = 0;
11939        if self.stream_message.is_some() {
11940            len += 1;
11941        }
11942        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11943        if let Some(v) = self.stream_message.as_ref() {
11944            match v {
11945                stream_message::StreamMessage::StreamChunk(v) => {
11946                    struct_ser.serialize_field("streamChunk", v)?;
11947                }
11948                stream_message::StreamMessage::Barrier(v) => {
11949                    struct_ser.serialize_field("barrier", v)?;
11950                }
11951                stream_message::StreamMessage::Watermark(v) => {
11952                    struct_ser.serialize_field("watermark", v)?;
11953                }
11954            }
11955        }
11956        struct_ser.end()
11957    }
11958}
11959impl<'de> serde::Deserialize<'de> for StreamMessage {
11960    #[allow(deprecated)]
11961    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11962    where
11963        D: serde::Deserializer<'de>,
11964    {
11965        const FIELDS: &[&str] = &[
11966            "stream_chunk",
11967            "streamChunk",
11968            "barrier",
11969            "watermark",
11970        ];
11971
11972        #[allow(clippy::enum_variant_names)]
11973        enum GeneratedField {
11974            StreamChunk,
11975            Barrier,
11976            Watermark,
11977        }
11978        impl<'de> serde::Deserialize<'de> for GeneratedField {
11979            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11980            where
11981                D: serde::Deserializer<'de>,
11982            {
11983                struct GeneratedVisitor;
11984
11985                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11986                    type Value = GeneratedField;
11987
11988                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11989                        write!(formatter, "expected one of: {:?}", &FIELDS)
11990                    }
11991
11992                    #[allow(unused_variables)]
11993                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11994                    where
11995                        E: serde::de::Error,
11996                    {
11997                        match value {
11998                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11999                            "barrier" => Ok(GeneratedField::Barrier),
12000                            "watermark" => Ok(GeneratedField::Watermark),
12001                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12002                        }
12003                    }
12004                }
12005                deserializer.deserialize_identifier(GeneratedVisitor)
12006            }
12007        }
12008        struct GeneratedVisitor;
12009        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12010            type Value = StreamMessage;
12011
12012            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12013                formatter.write_str("struct stream_plan.StreamMessage")
12014            }
12015
12016            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
12017                where
12018                    V: serde::de::MapAccess<'de>,
12019            {
12020                let mut stream_message__ = None;
12021                while let Some(k) = map_.next_key()? {
12022                    match k {
12023                        GeneratedField::StreamChunk => {
12024                            if stream_message__.is_some() {
12025                                return Err(serde::de::Error::duplicate_field("streamChunk"));
12026                            }
12027                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
12028;
12029                        }
12030                        GeneratedField::Barrier => {
12031                            if stream_message__.is_some() {
12032                                return Err(serde::de::Error::duplicate_field("barrier"));
12033                            }
12034                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
12035;
12036                        }
12037                        GeneratedField::Watermark => {
12038                            if stream_message__.is_some() {
12039                                return Err(serde::de::Error::duplicate_field("watermark"));
12040                            }
12041                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
12042;
12043                        }
12044                    }
12045                }
12046                Ok(StreamMessage {
12047                    stream_message: stream_message__,
12048                })
12049            }
12050        }
12051        deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
12052    }
12053}
12054impl serde::Serialize for StreamMessageBatch {
12055    #[allow(deprecated)]
12056    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12057    where
12058        S: serde::Serializer,
12059    {
12060        use serde::ser::SerializeStruct;
12061        let mut len = 0;
12062        if self.stream_message_batch.is_some() {
12063            len += 1;
12064        }
12065        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12066        if let Some(v) = self.stream_message_batch.as_ref() {
12067            match v {
12068                stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12069                    struct_ser.serialize_field("streamChunk", v)?;
12070                }
12071                stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12072                    struct_ser.serialize_field("barrierBatch", v)?;
12073                }
12074                stream_message_batch::StreamMessageBatch::Watermark(v) => {
12075                    struct_ser.serialize_field("watermark", v)?;
12076                }
12077            }
12078        }
12079        struct_ser.end()
12080    }
12081}
12082impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12083    #[allow(deprecated)]
12084    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12085    where
12086        D: serde::Deserializer<'de>,
12087    {
12088        const FIELDS: &[&str] = &[
12089            "stream_chunk",
12090            "streamChunk",
12091            "barrier_batch",
12092            "barrierBatch",
12093            "watermark",
12094        ];
12095
12096        #[allow(clippy::enum_variant_names)]
12097        enum GeneratedField {
12098            StreamChunk,
12099            BarrierBatch,
12100            Watermark,
12101        }
12102        impl<'de> serde::Deserialize<'de> for GeneratedField {
12103            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12104            where
12105                D: serde::Deserializer<'de>,
12106            {
12107                struct GeneratedVisitor;
12108
12109                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12110                    type Value = GeneratedField;
12111
12112                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12113                        write!(formatter, "expected one of: {:?}", &FIELDS)
12114                    }
12115
12116                    #[allow(unused_variables)]
12117                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12118                    where
12119                        E: serde::de::Error,
12120                    {
12121                        match value {
12122                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12123                            "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12124                            "watermark" => Ok(GeneratedField::Watermark),
12125                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12126                        }
12127                    }
12128                }
12129                deserializer.deserialize_identifier(GeneratedVisitor)
12130            }
12131        }
12132        struct GeneratedVisitor;
12133        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12134            type Value = StreamMessageBatch;
12135
12136            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12137                formatter.write_str("struct stream_plan.StreamMessageBatch")
12138            }
12139
12140            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12141                where
12142                    V: serde::de::MapAccess<'de>,
12143            {
12144                let mut stream_message_batch__ = None;
12145                while let Some(k) = map_.next_key()? {
12146                    match k {
12147                        GeneratedField::StreamChunk => {
12148                            if stream_message_batch__.is_some() {
12149                                return Err(serde::de::Error::duplicate_field("streamChunk"));
12150                            }
12151                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12152;
12153                        }
12154                        GeneratedField::BarrierBatch => {
12155                            if stream_message_batch__.is_some() {
12156                                return Err(serde::de::Error::duplicate_field("barrierBatch"));
12157                            }
12158                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12159;
12160                        }
12161                        GeneratedField::Watermark => {
12162                            if stream_message_batch__.is_some() {
12163                                return Err(serde::de::Error::duplicate_field("watermark"));
12164                            }
12165                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12166;
12167                        }
12168                    }
12169                }
12170                Ok(StreamMessageBatch {
12171                    stream_message_batch: stream_message_batch__,
12172                })
12173            }
12174        }
12175        deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12176    }
12177}
12178impl serde::Serialize for stream_message_batch::BarrierBatch {
12179    #[allow(deprecated)]
12180    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12181    where
12182        S: serde::Serializer,
12183    {
12184        use serde::ser::SerializeStruct;
12185        let mut len = 0;
12186        if !self.barriers.is_empty() {
12187            len += 1;
12188        }
12189        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12190        if !self.barriers.is_empty() {
12191            struct_ser.serialize_field("barriers", &self.barriers)?;
12192        }
12193        struct_ser.end()
12194    }
12195}
12196impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12197    #[allow(deprecated)]
12198    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12199    where
12200        D: serde::Deserializer<'de>,
12201    {
12202        const FIELDS: &[&str] = &[
12203            "barriers",
12204        ];
12205
12206        #[allow(clippy::enum_variant_names)]
12207        enum GeneratedField {
12208            Barriers,
12209        }
12210        impl<'de> serde::Deserialize<'de> for GeneratedField {
12211            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12212            where
12213                D: serde::Deserializer<'de>,
12214            {
12215                struct GeneratedVisitor;
12216
12217                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12218                    type Value = GeneratedField;
12219
12220                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12221                        write!(formatter, "expected one of: {:?}", &FIELDS)
12222                    }
12223
12224                    #[allow(unused_variables)]
12225                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12226                    where
12227                        E: serde::de::Error,
12228                    {
12229                        match value {
12230                            "barriers" => Ok(GeneratedField::Barriers),
12231                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12232                        }
12233                    }
12234                }
12235                deserializer.deserialize_identifier(GeneratedVisitor)
12236            }
12237        }
12238        struct GeneratedVisitor;
12239        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12240            type Value = stream_message_batch::BarrierBatch;
12241
12242            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12243                formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12244            }
12245
12246            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12247                where
12248                    V: serde::de::MapAccess<'de>,
12249            {
12250                let mut barriers__ = None;
12251                while let Some(k) = map_.next_key()? {
12252                    match k {
12253                        GeneratedField::Barriers => {
12254                            if barriers__.is_some() {
12255                                return Err(serde::de::Error::duplicate_field("barriers"));
12256                            }
12257                            barriers__ = Some(map_.next_value()?);
12258                        }
12259                    }
12260                }
12261                Ok(stream_message_batch::BarrierBatch {
12262                    barriers: barriers__.unwrap_or_default(),
12263                })
12264            }
12265        }
12266        deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12267    }
12268}
12269impl serde::Serialize for StreamNode {
12270    #[allow(deprecated)]
12271    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12272    where
12273        S: serde::Serializer,
12274    {
12275        use serde::ser::SerializeStruct;
12276        let mut len = 0;
12277        if self.operator_id != 0 {
12278            len += 1;
12279        }
12280        if !self.input.is_empty() {
12281            len += 1;
12282        }
12283        if !self.stream_key.is_empty() {
12284            len += 1;
12285        }
12286        if self.stream_kind != 0 {
12287            len += 1;
12288        }
12289        if !self.identity.is_empty() {
12290            len += 1;
12291        }
12292        if !self.fields.is_empty() {
12293            len += 1;
12294        }
12295        if self.node_body.is_some() {
12296            len += 1;
12297        }
12298        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12299        if self.operator_id != 0 {
12300            #[allow(clippy::needless_borrow)]
12301            #[allow(clippy::needless_borrows_for_generic_args)]
12302            struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12303        }
12304        if !self.input.is_empty() {
12305            struct_ser.serialize_field("input", &self.input)?;
12306        }
12307        if !self.stream_key.is_empty() {
12308            struct_ser.serialize_field("streamKey", &self.stream_key)?;
12309        }
12310        if self.stream_kind != 0 {
12311            let v = stream_node::StreamKind::try_from(self.stream_kind)
12312                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12313            struct_ser.serialize_field("streamKind", &v)?;
12314        }
12315        if !self.identity.is_empty() {
12316            struct_ser.serialize_field("identity", &self.identity)?;
12317        }
12318        if !self.fields.is_empty() {
12319            struct_ser.serialize_field("fields", &self.fields)?;
12320        }
12321        if let Some(v) = self.node_body.as_ref() {
12322            match v {
12323                stream_node::NodeBody::Source(v) => {
12324                    struct_ser.serialize_field("source", v)?;
12325                }
12326                stream_node::NodeBody::Project(v) => {
12327                    struct_ser.serialize_field("project", v)?;
12328                }
12329                stream_node::NodeBody::Filter(v) => {
12330                    struct_ser.serialize_field("filter", v)?;
12331                }
12332                stream_node::NodeBody::Materialize(v) => {
12333                    struct_ser.serialize_field("materialize", v)?;
12334                }
12335                stream_node::NodeBody::StatelessSimpleAgg(v) => {
12336                    struct_ser.serialize_field("statelessSimpleAgg", v)?;
12337                }
12338                stream_node::NodeBody::SimpleAgg(v) => {
12339                    struct_ser.serialize_field("simpleAgg", v)?;
12340                }
12341                stream_node::NodeBody::HashAgg(v) => {
12342                    struct_ser.serialize_field("hashAgg", v)?;
12343                }
12344                stream_node::NodeBody::AppendOnlyTopN(v) => {
12345                    struct_ser.serialize_field("appendOnlyTopN", v)?;
12346                }
12347                stream_node::NodeBody::HashJoin(v) => {
12348                    struct_ser.serialize_field("hashJoin", v)?;
12349                }
12350                stream_node::NodeBody::TopN(v) => {
12351                    struct_ser.serialize_field("topN", v)?;
12352                }
12353                stream_node::NodeBody::HopWindow(v) => {
12354                    struct_ser.serialize_field("hopWindow", v)?;
12355                }
12356                stream_node::NodeBody::Merge(v) => {
12357                    struct_ser.serialize_field("merge", v)?;
12358                }
12359                stream_node::NodeBody::Exchange(v) => {
12360                    struct_ser.serialize_field("exchange", v)?;
12361                }
12362                stream_node::NodeBody::StreamScan(v) => {
12363                    struct_ser.serialize_field("streamScan", v)?;
12364                }
12365                stream_node::NodeBody::BatchPlan(v) => {
12366                    struct_ser.serialize_field("batchPlan", v)?;
12367                }
12368                stream_node::NodeBody::Lookup(v) => {
12369                    struct_ser.serialize_field("lookup", v)?;
12370                }
12371                stream_node::NodeBody::Arrange(v) => {
12372                    struct_ser.serialize_field("arrange", v)?;
12373                }
12374                stream_node::NodeBody::LookupUnion(v) => {
12375                    struct_ser.serialize_field("lookupUnion", v)?;
12376                }
12377                stream_node::NodeBody::Union(v) => {
12378                    struct_ser.serialize_field("union", v)?;
12379                }
12380                stream_node::NodeBody::DeltaIndexJoin(v) => {
12381                    struct_ser.serialize_field("deltaIndexJoin", v)?;
12382                }
12383                stream_node::NodeBody::Sink(v) => {
12384                    struct_ser.serialize_field("sink", v)?;
12385                }
12386                stream_node::NodeBody::Expand(v) => {
12387                    struct_ser.serialize_field("expand", v)?;
12388                }
12389                stream_node::NodeBody::DynamicFilter(v) => {
12390                    struct_ser.serialize_field("dynamicFilter", v)?;
12391                }
12392                stream_node::NodeBody::ProjectSet(v) => {
12393                    struct_ser.serialize_field("projectSet", v)?;
12394                }
12395                stream_node::NodeBody::GroupTopN(v) => {
12396                    struct_ser.serialize_field("groupTopN", v)?;
12397                }
12398                stream_node::NodeBody::Sort(v) => {
12399                    struct_ser.serialize_field("sort", v)?;
12400                }
12401                stream_node::NodeBody::WatermarkFilter(v) => {
12402                    struct_ser.serialize_field("watermarkFilter", v)?;
12403                }
12404                stream_node::NodeBody::Dml(v) => {
12405                    struct_ser.serialize_field("dml", v)?;
12406                }
12407                stream_node::NodeBody::RowIdGen(v) => {
12408                    struct_ser.serialize_field("rowIdGen", v)?;
12409                }
12410                stream_node::NodeBody::Now(v) => {
12411                    struct_ser.serialize_field("now", v)?;
12412                }
12413                stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
12414                    struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
12415                }
12416                stream_node::NodeBody::TemporalJoin(v) => {
12417                    struct_ser.serialize_field("temporalJoin", v)?;
12418                }
12419                stream_node::NodeBody::BarrierRecv(v) => {
12420                    struct_ser.serialize_field("barrierRecv", v)?;
12421                }
12422                stream_node::NodeBody::Values(v) => {
12423                    struct_ser.serialize_field("values", v)?;
12424                }
12425                stream_node::NodeBody::AppendOnlyDedup(v) => {
12426                    struct_ser.serialize_field("appendOnlyDedup", v)?;
12427                }
12428                stream_node::NodeBody::NoOp(v) => {
12429                    struct_ser.serialize_field("noOp", v)?;
12430                }
12431                stream_node::NodeBody::EowcOverWindow(v) => {
12432                    struct_ser.serialize_field("eowcOverWindow", v)?;
12433                }
12434                stream_node::NodeBody::OverWindow(v) => {
12435                    struct_ser.serialize_field("overWindow", v)?;
12436                }
12437                stream_node::NodeBody::StreamFsFetch(v) => {
12438                    struct_ser.serialize_field("streamFsFetch", v)?;
12439                }
12440                stream_node::NodeBody::StreamCdcScan(v) => {
12441                    struct_ser.serialize_field("streamCdcScan", v)?;
12442                }
12443                stream_node::NodeBody::CdcFilter(v) => {
12444                    struct_ser.serialize_field("cdcFilter", v)?;
12445                }
12446                stream_node::NodeBody::SourceBackfill(v) => {
12447                    struct_ser.serialize_field("sourceBackfill", v)?;
12448                }
12449                stream_node::NodeBody::Changelog(v) => {
12450                    struct_ser.serialize_field("changelog", v)?;
12451                }
12452                stream_node::NodeBody::LocalApproxPercentile(v) => {
12453                    struct_ser.serialize_field("localApproxPercentile", v)?;
12454                }
12455                stream_node::NodeBody::GlobalApproxPercentile(v) => {
12456                    struct_ser.serialize_field("globalApproxPercentile", v)?;
12457                }
12458                stream_node::NodeBody::RowMerge(v) => {
12459                    struct_ser.serialize_field("rowMerge", v)?;
12460                }
12461                stream_node::NodeBody::AsOfJoin(v) => {
12462                    struct_ser.serialize_field("asOfJoin", v)?;
12463                }
12464                stream_node::NodeBody::SyncLogStore(v) => {
12465                    struct_ser.serialize_field("syncLogStore", v)?;
12466                }
12467                stream_node::NodeBody::MaterializedExprs(v) => {
12468                    struct_ser.serialize_field("materializedExprs", v)?;
12469                }
12470                stream_node::NodeBody::VectorIndexWrite(v) => {
12471                    struct_ser.serialize_field("vectorIndexWrite", v)?;
12472                }
12473                stream_node::NodeBody::UpstreamSinkUnion(v) => {
12474                    struct_ser.serialize_field("upstreamSinkUnion", v)?;
12475                }
12476            }
12477        }
12478        struct_ser.end()
12479    }
12480}
12481impl<'de> serde::Deserialize<'de> for StreamNode {
12482    #[allow(deprecated)]
12483    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12484    where
12485        D: serde::Deserializer<'de>,
12486    {
12487        const FIELDS: &[&str] = &[
12488            "operator_id",
12489            "operatorId",
12490            "input",
12491            "stream_key",
12492            "streamKey",
12493            "stream_kind",
12494            "streamKind",
12495            "identity",
12496            "fields",
12497            "source",
12498            "project",
12499            "filter",
12500            "materialize",
12501            "stateless_simple_agg",
12502            "statelessSimpleAgg",
12503            "simple_agg",
12504            "simpleAgg",
12505            "hash_agg",
12506            "hashAgg",
12507            "append_only_top_n",
12508            "appendOnlyTopN",
12509            "hash_join",
12510            "hashJoin",
12511            "top_n",
12512            "topN",
12513            "hop_window",
12514            "hopWindow",
12515            "merge",
12516            "exchange",
12517            "stream_scan",
12518            "streamScan",
12519            "batch_plan",
12520            "batchPlan",
12521            "lookup",
12522            "arrange",
12523            "lookup_union",
12524            "lookupUnion",
12525            "union",
12526            "delta_index_join",
12527            "deltaIndexJoin",
12528            "sink",
12529            "expand",
12530            "dynamic_filter",
12531            "dynamicFilter",
12532            "project_set",
12533            "projectSet",
12534            "group_top_n",
12535            "groupTopN",
12536            "sort",
12537            "watermark_filter",
12538            "watermarkFilter",
12539            "dml",
12540            "row_id_gen",
12541            "rowIdGen",
12542            "now",
12543            "append_only_group_top_n",
12544            "appendOnlyGroupTopN",
12545            "temporal_join",
12546            "temporalJoin",
12547            "barrier_recv",
12548            "barrierRecv",
12549            "values",
12550            "append_only_dedup",
12551            "appendOnlyDedup",
12552            "no_op",
12553            "noOp",
12554            "eowc_over_window",
12555            "eowcOverWindow",
12556            "over_window",
12557            "overWindow",
12558            "stream_fs_fetch",
12559            "streamFsFetch",
12560            "stream_cdc_scan",
12561            "streamCdcScan",
12562            "cdc_filter",
12563            "cdcFilter",
12564            "source_backfill",
12565            "sourceBackfill",
12566            "changelog",
12567            "local_approx_percentile",
12568            "localApproxPercentile",
12569            "global_approx_percentile",
12570            "globalApproxPercentile",
12571            "row_merge",
12572            "rowMerge",
12573            "as_of_join",
12574            "asOfJoin",
12575            "sync_log_store",
12576            "syncLogStore",
12577            "materialized_exprs",
12578            "materializedExprs",
12579            "vector_index_write",
12580            "vectorIndexWrite",
12581            "upstream_sink_union",
12582            "upstreamSinkUnion",
12583        ];
12584
12585        #[allow(clippy::enum_variant_names)]
12586        enum GeneratedField {
12587            OperatorId,
12588            Input,
12589            StreamKey,
12590            StreamKind,
12591            Identity,
12592            Fields,
12593            Source,
12594            Project,
12595            Filter,
12596            Materialize,
12597            StatelessSimpleAgg,
12598            SimpleAgg,
12599            HashAgg,
12600            AppendOnlyTopN,
12601            HashJoin,
12602            TopN,
12603            HopWindow,
12604            Merge,
12605            Exchange,
12606            StreamScan,
12607            BatchPlan,
12608            Lookup,
12609            Arrange,
12610            LookupUnion,
12611            Union,
12612            DeltaIndexJoin,
12613            Sink,
12614            Expand,
12615            DynamicFilter,
12616            ProjectSet,
12617            GroupTopN,
12618            Sort,
12619            WatermarkFilter,
12620            Dml,
12621            RowIdGen,
12622            Now,
12623            AppendOnlyGroupTopN,
12624            TemporalJoin,
12625            BarrierRecv,
12626            Values,
12627            AppendOnlyDedup,
12628            NoOp,
12629            EowcOverWindow,
12630            OverWindow,
12631            StreamFsFetch,
12632            StreamCdcScan,
12633            CdcFilter,
12634            SourceBackfill,
12635            Changelog,
12636            LocalApproxPercentile,
12637            GlobalApproxPercentile,
12638            RowMerge,
12639            AsOfJoin,
12640            SyncLogStore,
12641            MaterializedExprs,
12642            VectorIndexWrite,
12643            UpstreamSinkUnion,
12644        }
12645        impl<'de> serde::Deserialize<'de> for GeneratedField {
12646            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12647            where
12648                D: serde::Deserializer<'de>,
12649            {
12650                struct GeneratedVisitor;
12651
12652                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12653                    type Value = GeneratedField;
12654
12655                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12656                        write!(formatter, "expected one of: {:?}", &FIELDS)
12657                    }
12658
12659                    #[allow(unused_variables)]
12660                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12661                    where
12662                        E: serde::de::Error,
12663                    {
12664                        match value {
12665                            "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12666                            "input" => Ok(GeneratedField::Input),
12667                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12668                            "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
12669                            "identity" => Ok(GeneratedField::Identity),
12670                            "fields" => Ok(GeneratedField::Fields),
12671                            "source" => Ok(GeneratedField::Source),
12672                            "project" => Ok(GeneratedField::Project),
12673                            "filter" => Ok(GeneratedField::Filter),
12674                            "materialize" => Ok(GeneratedField::Materialize),
12675                            "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12676                            "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12677                            "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12678                            "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12679                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12680                            "topN" | "top_n" => Ok(GeneratedField::TopN),
12681                            "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12682                            "merge" => Ok(GeneratedField::Merge),
12683                            "exchange" => Ok(GeneratedField::Exchange),
12684                            "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12685                            "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12686                            "lookup" => Ok(GeneratedField::Lookup),
12687                            "arrange" => Ok(GeneratedField::Arrange),
12688                            "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12689                            "union" => Ok(GeneratedField::Union),
12690                            "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12691                            "sink" => Ok(GeneratedField::Sink),
12692                            "expand" => Ok(GeneratedField::Expand),
12693                            "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12694                            "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12695                            "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12696                            "sort" => Ok(GeneratedField::Sort),
12697                            "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12698                            "dml" => Ok(GeneratedField::Dml),
12699                            "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12700                            "now" => Ok(GeneratedField::Now),
12701                            "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12702                            "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12703                            "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12704                            "values" => Ok(GeneratedField::Values),
12705                            "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12706                            "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12707                            "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12708                            "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12709                            "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12710                            "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12711                            "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12712                            "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12713                            "changelog" => Ok(GeneratedField::Changelog),
12714                            "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12715                            "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12716                            "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12717                            "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12718                            "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12719                            "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12720                            "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
12721                            "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
12722                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12723                        }
12724                    }
12725                }
12726                deserializer.deserialize_identifier(GeneratedVisitor)
12727            }
12728        }
12729        struct GeneratedVisitor;
12730        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12731            type Value = StreamNode;
12732
12733            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12734                formatter.write_str("struct stream_plan.StreamNode")
12735            }
12736
12737            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12738                where
12739                    V: serde::de::MapAccess<'de>,
12740            {
12741                let mut operator_id__ = None;
12742                let mut input__ = None;
12743                let mut stream_key__ = None;
12744                let mut stream_kind__ = None;
12745                let mut identity__ = None;
12746                let mut fields__ = None;
12747                let mut node_body__ = None;
12748                while let Some(k) = map_.next_key()? {
12749                    match k {
12750                        GeneratedField::OperatorId => {
12751                            if operator_id__.is_some() {
12752                                return Err(serde::de::Error::duplicate_field("operatorId"));
12753                            }
12754                            operator_id__ = 
12755                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12756                            ;
12757                        }
12758                        GeneratedField::Input => {
12759                            if input__.is_some() {
12760                                return Err(serde::de::Error::duplicate_field("input"));
12761                            }
12762                            input__ = Some(map_.next_value()?);
12763                        }
12764                        GeneratedField::StreamKey => {
12765                            if stream_key__.is_some() {
12766                                return Err(serde::de::Error::duplicate_field("streamKey"));
12767                            }
12768                            stream_key__ = 
12769                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12770                                    .into_iter().map(|x| x.0).collect())
12771                            ;
12772                        }
12773                        GeneratedField::StreamKind => {
12774                            if stream_kind__.is_some() {
12775                                return Err(serde::de::Error::duplicate_field("streamKind"));
12776                            }
12777                            stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
12778                        }
12779                        GeneratedField::Identity => {
12780                            if identity__.is_some() {
12781                                return Err(serde::de::Error::duplicate_field("identity"));
12782                            }
12783                            identity__ = Some(map_.next_value()?);
12784                        }
12785                        GeneratedField::Fields => {
12786                            if fields__.is_some() {
12787                                return Err(serde::de::Error::duplicate_field("fields"));
12788                            }
12789                            fields__ = Some(map_.next_value()?);
12790                        }
12791                        GeneratedField::Source => {
12792                            if node_body__.is_some() {
12793                                return Err(serde::de::Error::duplicate_field("source"));
12794                            }
12795                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12796;
12797                        }
12798                        GeneratedField::Project => {
12799                            if node_body__.is_some() {
12800                                return Err(serde::de::Error::duplicate_field("project"));
12801                            }
12802                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12803;
12804                        }
12805                        GeneratedField::Filter => {
12806                            if node_body__.is_some() {
12807                                return Err(serde::de::Error::duplicate_field("filter"));
12808                            }
12809                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12810;
12811                        }
12812                        GeneratedField::Materialize => {
12813                            if node_body__.is_some() {
12814                                return Err(serde::de::Error::duplicate_field("materialize"));
12815                            }
12816                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12817;
12818                        }
12819                        GeneratedField::StatelessSimpleAgg => {
12820                            if node_body__.is_some() {
12821                                return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12822                            }
12823                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12824;
12825                        }
12826                        GeneratedField::SimpleAgg => {
12827                            if node_body__.is_some() {
12828                                return Err(serde::de::Error::duplicate_field("simpleAgg"));
12829                            }
12830                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12831;
12832                        }
12833                        GeneratedField::HashAgg => {
12834                            if node_body__.is_some() {
12835                                return Err(serde::de::Error::duplicate_field("hashAgg"));
12836                            }
12837                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12838;
12839                        }
12840                        GeneratedField::AppendOnlyTopN => {
12841                            if node_body__.is_some() {
12842                                return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12843                            }
12844                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12845;
12846                        }
12847                        GeneratedField::HashJoin => {
12848                            if node_body__.is_some() {
12849                                return Err(serde::de::Error::duplicate_field("hashJoin"));
12850                            }
12851                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12852;
12853                        }
12854                        GeneratedField::TopN => {
12855                            if node_body__.is_some() {
12856                                return Err(serde::de::Error::duplicate_field("topN"));
12857                            }
12858                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12859;
12860                        }
12861                        GeneratedField::HopWindow => {
12862                            if node_body__.is_some() {
12863                                return Err(serde::de::Error::duplicate_field("hopWindow"));
12864                            }
12865                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12866;
12867                        }
12868                        GeneratedField::Merge => {
12869                            if node_body__.is_some() {
12870                                return Err(serde::de::Error::duplicate_field("merge"));
12871                            }
12872                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12873;
12874                        }
12875                        GeneratedField::Exchange => {
12876                            if node_body__.is_some() {
12877                                return Err(serde::de::Error::duplicate_field("exchange"));
12878                            }
12879                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12880;
12881                        }
12882                        GeneratedField::StreamScan => {
12883                            if node_body__.is_some() {
12884                                return Err(serde::de::Error::duplicate_field("streamScan"));
12885                            }
12886                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12887;
12888                        }
12889                        GeneratedField::BatchPlan => {
12890                            if node_body__.is_some() {
12891                                return Err(serde::de::Error::duplicate_field("batchPlan"));
12892                            }
12893                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12894;
12895                        }
12896                        GeneratedField::Lookup => {
12897                            if node_body__.is_some() {
12898                                return Err(serde::de::Error::duplicate_field("lookup"));
12899                            }
12900                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12901;
12902                        }
12903                        GeneratedField::Arrange => {
12904                            if node_body__.is_some() {
12905                                return Err(serde::de::Error::duplicate_field("arrange"));
12906                            }
12907                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12908;
12909                        }
12910                        GeneratedField::LookupUnion => {
12911                            if node_body__.is_some() {
12912                                return Err(serde::de::Error::duplicate_field("lookupUnion"));
12913                            }
12914                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12915;
12916                        }
12917                        GeneratedField::Union => {
12918                            if node_body__.is_some() {
12919                                return Err(serde::de::Error::duplicate_field("union"));
12920                            }
12921                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12922;
12923                        }
12924                        GeneratedField::DeltaIndexJoin => {
12925                            if node_body__.is_some() {
12926                                return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12927                            }
12928                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12929;
12930                        }
12931                        GeneratedField::Sink => {
12932                            if node_body__.is_some() {
12933                                return Err(serde::de::Error::duplicate_field("sink"));
12934                            }
12935                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12936;
12937                        }
12938                        GeneratedField::Expand => {
12939                            if node_body__.is_some() {
12940                                return Err(serde::de::Error::duplicate_field("expand"));
12941                            }
12942                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12943;
12944                        }
12945                        GeneratedField::DynamicFilter => {
12946                            if node_body__.is_some() {
12947                                return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12948                            }
12949                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12950;
12951                        }
12952                        GeneratedField::ProjectSet => {
12953                            if node_body__.is_some() {
12954                                return Err(serde::de::Error::duplicate_field("projectSet"));
12955                            }
12956                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12957;
12958                        }
12959                        GeneratedField::GroupTopN => {
12960                            if node_body__.is_some() {
12961                                return Err(serde::de::Error::duplicate_field("groupTopN"));
12962                            }
12963                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12964;
12965                        }
12966                        GeneratedField::Sort => {
12967                            if node_body__.is_some() {
12968                                return Err(serde::de::Error::duplicate_field("sort"));
12969                            }
12970                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12971;
12972                        }
12973                        GeneratedField::WatermarkFilter => {
12974                            if node_body__.is_some() {
12975                                return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12976                            }
12977                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12978;
12979                        }
12980                        GeneratedField::Dml => {
12981                            if node_body__.is_some() {
12982                                return Err(serde::de::Error::duplicate_field("dml"));
12983                            }
12984                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12985;
12986                        }
12987                        GeneratedField::RowIdGen => {
12988                            if node_body__.is_some() {
12989                                return Err(serde::de::Error::duplicate_field("rowIdGen"));
12990                            }
12991                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12992;
12993                        }
12994                        GeneratedField::Now => {
12995                            if node_body__.is_some() {
12996                                return Err(serde::de::Error::duplicate_field("now"));
12997                            }
12998                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12999;
13000                        }
13001                        GeneratedField::AppendOnlyGroupTopN => {
13002                            if node_body__.is_some() {
13003                                return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
13004                            }
13005                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
13006;
13007                        }
13008                        GeneratedField::TemporalJoin => {
13009                            if node_body__.is_some() {
13010                                return Err(serde::de::Error::duplicate_field("temporalJoin"));
13011                            }
13012                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
13013;
13014                        }
13015                        GeneratedField::BarrierRecv => {
13016                            if node_body__.is_some() {
13017                                return Err(serde::de::Error::duplicate_field("barrierRecv"));
13018                            }
13019                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
13020;
13021                        }
13022                        GeneratedField::Values => {
13023                            if node_body__.is_some() {
13024                                return Err(serde::de::Error::duplicate_field("values"));
13025                            }
13026                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
13027;
13028                        }
13029                        GeneratedField::AppendOnlyDedup => {
13030                            if node_body__.is_some() {
13031                                return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
13032                            }
13033                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
13034;
13035                        }
13036                        GeneratedField::NoOp => {
13037                            if node_body__.is_some() {
13038                                return Err(serde::de::Error::duplicate_field("noOp"));
13039                            }
13040                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
13041;
13042                        }
13043                        GeneratedField::EowcOverWindow => {
13044                            if node_body__.is_some() {
13045                                return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
13046                            }
13047                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
13048;
13049                        }
13050                        GeneratedField::OverWindow => {
13051                            if node_body__.is_some() {
13052                                return Err(serde::de::Error::duplicate_field("overWindow"));
13053                            }
13054                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
13055;
13056                        }
13057                        GeneratedField::StreamFsFetch => {
13058                            if node_body__.is_some() {
13059                                return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13060                            }
13061                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13062;
13063                        }
13064                        GeneratedField::StreamCdcScan => {
13065                            if node_body__.is_some() {
13066                                return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13067                            }
13068                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13069;
13070                        }
13071                        GeneratedField::CdcFilter => {
13072                            if node_body__.is_some() {
13073                                return Err(serde::de::Error::duplicate_field("cdcFilter"));
13074                            }
13075                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13076;
13077                        }
13078                        GeneratedField::SourceBackfill => {
13079                            if node_body__.is_some() {
13080                                return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13081                            }
13082                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13083;
13084                        }
13085                        GeneratedField::Changelog => {
13086                            if node_body__.is_some() {
13087                                return Err(serde::de::Error::duplicate_field("changelog"));
13088                            }
13089                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13090;
13091                        }
13092                        GeneratedField::LocalApproxPercentile => {
13093                            if node_body__.is_some() {
13094                                return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13095                            }
13096                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13097;
13098                        }
13099                        GeneratedField::GlobalApproxPercentile => {
13100                            if node_body__.is_some() {
13101                                return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13102                            }
13103                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13104;
13105                        }
13106                        GeneratedField::RowMerge => {
13107                            if node_body__.is_some() {
13108                                return Err(serde::de::Error::duplicate_field("rowMerge"));
13109                            }
13110                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13111;
13112                        }
13113                        GeneratedField::AsOfJoin => {
13114                            if node_body__.is_some() {
13115                                return Err(serde::de::Error::duplicate_field("asOfJoin"));
13116                            }
13117                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13118;
13119                        }
13120                        GeneratedField::SyncLogStore => {
13121                            if node_body__.is_some() {
13122                                return Err(serde::de::Error::duplicate_field("syncLogStore"));
13123                            }
13124                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13125;
13126                        }
13127                        GeneratedField::MaterializedExprs => {
13128                            if node_body__.is_some() {
13129                                return Err(serde::de::Error::duplicate_field("materializedExprs"));
13130                            }
13131                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13132;
13133                        }
13134                        GeneratedField::VectorIndexWrite => {
13135                            if node_body__.is_some() {
13136                                return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13137                            }
13138                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13139;
13140                        }
13141                        GeneratedField::UpstreamSinkUnion => {
13142                            if node_body__.is_some() {
13143                                return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13144                            }
13145                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13146;
13147                        }
13148                    }
13149                }
13150                Ok(StreamNode {
13151                    operator_id: operator_id__.unwrap_or_default(),
13152                    input: input__.unwrap_or_default(),
13153                    stream_key: stream_key__.unwrap_or_default(),
13154                    stream_kind: stream_kind__.unwrap_or_default(),
13155                    identity: identity__.unwrap_or_default(),
13156                    fields: fields__.unwrap_or_default(),
13157                    node_body: node_body__,
13158                })
13159            }
13160        }
13161        deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13162    }
13163}
13164impl serde::Serialize for stream_node::StreamKind {
13165    #[allow(deprecated)]
13166    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13167    where
13168        S: serde::Serializer,
13169    {
13170        let variant = match self {
13171            Self::Retract => "STREAM_KIND_RETRACT",
13172            Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13173            Self::Upsert => "STREAM_KIND_UPSERT",
13174        };
13175        serializer.serialize_str(variant)
13176    }
13177}
13178impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13179    #[allow(deprecated)]
13180    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13181    where
13182        D: serde::Deserializer<'de>,
13183    {
13184        const FIELDS: &[&str] = &[
13185            "STREAM_KIND_RETRACT",
13186            "STREAM_KIND_APPEND_ONLY",
13187            "STREAM_KIND_UPSERT",
13188        ];
13189
13190        struct GeneratedVisitor;
13191
13192        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13193            type Value = stream_node::StreamKind;
13194
13195            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13196                write!(formatter, "expected one of: {:?}", &FIELDS)
13197            }
13198
13199            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13200            where
13201                E: serde::de::Error,
13202            {
13203                i32::try_from(v)
13204                    .ok()
13205                    .and_then(|x| x.try_into().ok())
13206                    .ok_or_else(|| {
13207                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13208                    })
13209            }
13210
13211            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13212            where
13213                E: serde::de::Error,
13214            {
13215                i32::try_from(v)
13216                    .ok()
13217                    .and_then(|x| x.try_into().ok())
13218                    .ok_or_else(|| {
13219                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13220                    })
13221            }
13222
13223            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13224            where
13225                E: serde::de::Error,
13226            {
13227                match value {
13228                    "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13229                    "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13230                    "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13231                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13232                }
13233            }
13234        }
13235        deserializer.deserialize_any(GeneratedVisitor)
13236    }
13237}
13238impl serde::Serialize for StreamScanNode {
13239    #[allow(deprecated)]
13240    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13241    where
13242        S: serde::Serializer,
13243    {
13244        use serde::ser::SerializeStruct;
13245        let mut len = 0;
13246        if self.table_id != 0 {
13247            len += 1;
13248        }
13249        if !self.upstream_column_ids.is_empty() {
13250            len += 1;
13251        }
13252        if !self.output_indices.is_empty() {
13253            len += 1;
13254        }
13255        if self.stream_scan_type != 0 {
13256            len += 1;
13257        }
13258        if self.state_table.is_some() {
13259            len += 1;
13260        }
13261        if self.table_desc.is_some() {
13262            len += 1;
13263        }
13264        if self.rate_limit.is_some() {
13265            len += 1;
13266        }
13267        if self.snapshot_read_barrier_interval != 0 {
13268            len += 1;
13269        }
13270        if self.arrangement_table.is_some() {
13271            len += 1;
13272        }
13273        if self.snapshot_backfill_epoch.is_some() {
13274            len += 1;
13275        }
13276        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13277        if self.table_id != 0 {
13278            struct_ser.serialize_field("tableId", &self.table_id)?;
13279        }
13280        if !self.upstream_column_ids.is_empty() {
13281            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13282        }
13283        if !self.output_indices.is_empty() {
13284            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13285        }
13286        if self.stream_scan_type != 0 {
13287            let v = StreamScanType::try_from(self.stream_scan_type)
13288                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13289            struct_ser.serialize_field("streamScanType", &v)?;
13290        }
13291        if let Some(v) = self.state_table.as_ref() {
13292            struct_ser.serialize_field("stateTable", v)?;
13293        }
13294        if let Some(v) = self.table_desc.as_ref() {
13295            struct_ser.serialize_field("tableDesc", v)?;
13296        }
13297        if let Some(v) = self.rate_limit.as_ref() {
13298            struct_ser.serialize_field("rateLimit", v)?;
13299        }
13300        if self.snapshot_read_barrier_interval != 0 {
13301            struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13302        }
13303        if let Some(v) = self.arrangement_table.as_ref() {
13304            struct_ser.serialize_field("arrangementTable", v)?;
13305        }
13306        if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13307            #[allow(clippy::needless_borrow)]
13308            #[allow(clippy::needless_borrows_for_generic_args)]
13309            struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13310        }
13311        struct_ser.end()
13312    }
13313}
13314impl<'de> serde::Deserialize<'de> for StreamScanNode {
13315    #[allow(deprecated)]
13316    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13317    where
13318        D: serde::Deserializer<'de>,
13319    {
13320        const FIELDS: &[&str] = &[
13321            "table_id",
13322            "tableId",
13323            "upstream_column_ids",
13324            "upstreamColumnIds",
13325            "output_indices",
13326            "outputIndices",
13327            "stream_scan_type",
13328            "streamScanType",
13329            "state_table",
13330            "stateTable",
13331            "table_desc",
13332            "tableDesc",
13333            "rate_limit",
13334            "rateLimit",
13335            "snapshot_read_barrier_interval",
13336            "snapshotReadBarrierInterval",
13337            "arrangement_table",
13338            "arrangementTable",
13339            "snapshot_backfill_epoch",
13340            "snapshotBackfillEpoch",
13341        ];
13342
13343        #[allow(clippy::enum_variant_names)]
13344        enum GeneratedField {
13345            TableId,
13346            UpstreamColumnIds,
13347            OutputIndices,
13348            StreamScanType,
13349            StateTable,
13350            TableDesc,
13351            RateLimit,
13352            SnapshotReadBarrierInterval,
13353            ArrangementTable,
13354            SnapshotBackfillEpoch,
13355        }
13356        impl<'de> serde::Deserialize<'de> for GeneratedField {
13357            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13358            where
13359                D: serde::Deserializer<'de>,
13360            {
13361                struct GeneratedVisitor;
13362
13363                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13364                    type Value = GeneratedField;
13365
13366                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13367                        write!(formatter, "expected one of: {:?}", &FIELDS)
13368                    }
13369
13370                    #[allow(unused_variables)]
13371                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13372                    where
13373                        E: serde::de::Error,
13374                    {
13375                        match value {
13376                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
13377                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
13378                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13379                            "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
13380                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13381                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13382                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13383                            "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
13384                            "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
13385                            "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
13386                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13387                        }
13388                    }
13389                }
13390                deserializer.deserialize_identifier(GeneratedVisitor)
13391            }
13392        }
13393        struct GeneratedVisitor;
13394        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13395            type Value = StreamScanNode;
13396
13397            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13398                formatter.write_str("struct stream_plan.StreamScanNode")
13399            }
13400
13401            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
13402                where
13403                    V: serde::de::MapAccess<'de>,
13404            {
13405                let mut table_id__ = None;
13406                let mut upstream_column_ids__ = None;
13407                let mut output_indices__ = None;
13408                let mut stream_scan_type__ = None;
13409                let mut state_table__ = None;
13410                let mut table_desc__ = None;
13411                let mut rate_limit__ = None;
13412                let mut snapshot_read_barrier_interval__ = None;
13413                let mut arrangement_table__ = None;
13414                let mut snapshot_backfill_epoch__ = None;
13415                while let Some(k) = map_.next_key()? {
13416                    match k {
13417                        GeneratedField::TableId => {
13418                            if table_id__.is_some() {
13419                                return Err(serde::de::Error::duplicate_field("tableId"));
13420                            }
13421                            table_id__ = 
13422                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13423                            ;
13424                        }
13425                        GeneratedField::UpstreamColumnIds => {
13426                            if upstream_column_ids__.is_some() {
13427                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
13428                            }
13429                            upstream_column_ids__ = 
13430                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13431                                    .into_iter().map(|x| x.0).collect())
13432                            ;
13433                        }
13434                        GeneratedField::OutputIndices => {
13435                            if output_indices__.is_some() {
13436                                return Err(serde::de::Error::duplicate_field("outputIndices"));
13437                            }
13438                            output_indices__ = 
13439                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13440                                    .into_iter().map(|x| x.0).collect())
13441                            ;
13442                        }
13443                        GeneratedField::StreamScanType => {
13444                            if stream_scan_type__.is_some() {
13445                                return Err(serde::de::Error::duplicate_field("streamScanType"));
13446                            }
13447                            stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
13448                        }
13449                        GeneratedField::StateTable => {
13450                            if state_table__.is_some() {
13451                                return Err(serde::de::Error::duplicate_field("stateTable"));
13452                            }
13453                            state_table__ = map_.next_value()?;
13454                        }
13455                        GeneratedField::TableDesc => {
13456                            if table_desc__.is_some() {
13457                                return Err(serde::de::Error::duplicate_field("tableDesc"));
13458                            }
13459                            table_desc__ = map_.next_value()?;
13460                        }
13461                        GeneratedField::RateLimit => {
13462                            if rate_limit__.is_some() {
13463                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13464                            }
13465                            rate_limit__ = 
13466                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13467                            ;
13468                        }
13469                        GeneratedField::SnapshotReadBarrierInterval => {
13470                            if snapshot_read_barrier_interval__.is_some() {
13471                                return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
13472                            }
13473                            snapshot_read_barrier_interval__ = 
13474                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13475                            ;
13476                        }
13477                        GeneratedField::ArrangementTable => {
13478                            if arrangement_table__.is_some() {
13479                                return Err(serde::de::Error::duplicate_field("arrangementTable"));
13480                            }
13481                            arrangement_table__ = map_.next_value()?;
13482                        }
13483                        GeneratedField::SnapshotBackfillEpoch => {
13484                            if snapshot_backfill_epoch__.is_some() {
13485                                return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
13486                            }
13487                            snapshot_backfill_epoch__ = 
13488                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13489                            ;
13490                        }
13491                    }
13492                }
13493                Ok(StreamScanNode {
13494                    table_id: table_id__.unwrap_or_default(),
13495                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
13496                    output_indices: output_indices__.unwrap_or_default(),
13497                    stream_scan_type: stream_scan_type__.unwrap_or_default(),
13498                    state_table: state_table__,
13499                    table_desc: table_desc__,
13500                    rate_limit: rate_limit__,
13501                    snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
13502                    arrangement_table: arrangement_table__,
13503                    snapshot_backfill_epoch: snapshot_backfill_epoch__,
13504                })
13505            }
13506        }
13507        deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
13508    }
13509}
13510impl serde::Serialize for StreamScanType {
13511    #[allow(deprecated)]
13512    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13513    where
13514        S: serde::Serializer,
13515    {
13516        let variant = match self {
13517            Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
13518            Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
13519            Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
13520            Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
13521            Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13522            Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13523            Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13524            Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13525        };
13526        serializer.serialize_str(variant)
13527    }
13528}
13529impl<'de> serde::Deserialize<'de> for StreamScanType {
13530    #[allow(deprecated)]
13531    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13532    where
13533        D: serde::Deserializer<'de>,
13534    {
13535        const FIELDS: &[&str] = &[
13536            "STREAM_SCAN_TYPE_UNSPECIFIED",
13537            "STREAM_SCAN_TYPE_CHAIN",
13538            "STREAM_SCAN_TYPE_REARRANGE",
13539            "STREAM_SCAN_TYPE_BACKFILL",
13540            "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13541            "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13542            "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13543            "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13544        ];
13545
13546        struct GeneratedVisitor;
13547
13548        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13549            type Value = StreamScanType;
13550
13551            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13552                write!(formatter, "expected one of: {:?}", &FIELDS)
13553            }
13554
13555            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13556            where
13557                E: serde::de::Error,
13558            {
13559                i32::try_from(v)
13560                    .ok()
13561                    .and_then(|x| x.try_into().ok())
13562                    .ok_or_else(|| {
13563                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13564                    })
13565            }
13566
13567            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13568            where
13569                E: serde::de::Error,
13570            {
13571                i32::try_from(v)
13572                    .ok()
13573                    .and_then(|x| x.try_into().ok())
13574                    .ok_or_else(|| {
13575                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13576                    })
13577            }
13578
13579            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13580            where
13581                E: serde::de::Error,
13582            {
13583                match value {
13584                    "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
13585                    "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
13586                    "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
13587                    "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
13588                    "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
13589                    "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
13590                    "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
13591                    "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
13592                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13593                }
13594            }
13595        }
13596        deserializer.deserialize_any(GeneratedVisitor)
13597    }
13598}
13599impl serde::Serialize for StreamSource {
13600    #[allow(deprecated)]
13601    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13602    where
13603        S: serde::Serializer,
13604    {
13605        use serde::ser::SerializeStruct;
13606        let mut len = 0;
13607        if self.source_id != 0 {
13608            len += 1;
13609        }
13610        if self.state_table.is_some() {
13611            len += 1;
13612        }
13613        if self.row_id_index.is_some() {
13614            len += 1;
13615        }
13616        if !self.columns.is_empty() {
13617            len += 1;
13618        }
13619        if !self.with_properties.is_empty() {
13620            len += 1;
13621        }
13622        if self.info.is_some() {
13623            len += 1;
13624        }
13625        if !self.source_name.is_empty() {
13626            len += 1;
13627        }
13628        if self.rate_limit.is_some() {
13629            len += 1;
13630        }
13631        if !self.secret_refs.is_empty() {
13632            len += 1;
13633        }
13634        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
13635        if self.source_id != 0 {
13636            struct_ser.serialize_field("sourceId", &self.source_id)?;
13637        }
13638        if let Some(v) = self.state_table.as_ref() {
13639            struct_ser.serialize_field("stateTable", v)?;
13640        }
13641        if let Some(v) = self.row_id_index.as_ref() {
13642            struct_ser.serialize_field("rowIdIndex", v)?;
13643        }
13644        if !self.columns.is_empty() {
13645            struct_ser.serialize_field("columns", &self.columns)?;
13646        }
13647        if !self.with_properties.is_empty() {
13648            struct_ser.serialize_field("withProperties", &self.with_properties)?;
13649        }
13650        if let Some(v) = self.info.as_ref() {
13651            struct_ser.serialize_field("info", v)?;
13652        }
13653        if !self.source_name.is_empty() {
13654            struct_ser.serialize_field("sourceName", &self.source_name)?;
13655        }
13656        if let Some(v) = self.rate_limit.as_ref() {
13657            struct_ser.serialize_field("rateLimit", v)?;
13658        }
13659        if !self.secret_refs.is_empty() {
13660            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13661        }
13662        struct_ser.end()
13663    }
13664}
13665impl<'de> serde::Deserialize<'de> for StreamSource {
13666    #[allow(deprecated)]
13667    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13668    where
13669        D: serde::Deserializer<'de>,
13670    {
13671        const FIELDS: &[&str] = &[
13672            "source_id",
13673            "sourceId",
13674            "state_table",
13675            "stateTable",
13676            "row_id_index",
13677            "rowIdIndex",
13678            "columns",
13679            "with_properties",
13680            "withProperties",
13681            "info",
13682            "source_name",
13683            "sourceName",
13684            "rate_limit",
13685            "rateLimit",
13686            "secret_refs",
13687            "secretRefs",
13688        ];
13689
13690        #[allow(clippy::enum_variant_names)]
13691        enum GeneratedField {
13692            SourceId,
13693            StateTable,
13694            RowIdIndex,
13695            Columns,
13696            WithProperties,
13697            Info,
13698            SourceName,
13699            RateLimit,
13700            SecretRefs,
13701        }
13702        impl<'de> serde::Deserialize<'de> for GeneratedField {
13703            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13704            where
13705                D: serde::Deserializer<'de>,
13706            {
13707                struct GeneratedVisitor;
13708
13709                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13710                    type Value = GeneratedField;
13711
13712                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13713                        write!(formatter, "expected one of: {:?}", &FIELDS)
13714                    }
13715
13716                    #[allow(unused_variables)]
13717                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13718                    where
13719                        E: serde::de::Error,
13720                    {
13721                        match value {
13722                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13723                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13724                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13725                            "columns" => Ok(GeneratedField::Columns),
13726                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13727                            "info" => Ok(GeneratedField::Info),
13728                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13729                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13730                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13731                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13732                        }
13733                    }
13734                }
13735                deserializer.deserialize_identifier(GeneratedVisitor)
13736            }
13737        }
13738        struct GeneratedVisitor;
13739        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13740            type Value = StreamSource;
13741
13742            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13743                formatter.write_str("struct stream_plan.StreamSource")
13744            }
13745
13746            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13747                where
13748                    V: serde::de::MapAccess<'de>,
13749            {
13750                let mut source_id__ = None;
13751                let mut state_table__ = None;
13752                let mut row_id_index__ = None;
13753                let mut columns__ = None;
13754                let mut with_properties__ = None;
13755                let mut info__ = None;
13756                let mut source_name__ = None;
13757                let mut rate_limit__ = None;
13758                let mut secret_refs__ = None;
13759                while let Some(k) = map_.next_key()? {
13760                    match k {
13761                        GeneratedField::SourceId => {
13762                            if source_id__.is_some() {
13763                                return Err(serde::de::Error::duplicate_field("sourceId"));
13764                            }
13765                            source_id__ = 
13766                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13767                            ;
13768                        }
13769                        GeneratedField::StateTable => {
13770                            if state_table__.is_some() {
13771                                return Err(serde::de::Error::duplicate_field("stateTable"));
13772                            }
13773                            state_table__ = map_.next_value()?;
13774                        }
13775                        GeneratedField::RowIdIndex => {
13776                            if row_id_index__.is_some() {
13777                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13778                            }
13779                            row_id_index__ = 
13780                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13781                            ;
13782                        }
13783                        GeneratedField::Columns => {
13784                            if columns__.is_some() {
13785                                return Err(serde::de::Error::duplicate_field("columns"));
13786                            }
13787                            columns__ = Some(map_.next_value()?);
13788                        }
13789                        GeneratedField::WithProperties => {
13790                            if with_properties__.is_some() {
13791                                return Err(serde::de::Error::duplicate_field("withProperties"));
13792                            }
13793                            with_properties__ = Some(
13794                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13795                            );
13796                        }
13797                        GeneratedField::Info => {
13798                            if info__.is_some() {
13799                                return Err(serde::de::Error::duplicate_field("info"));
13800                            }
13801                            info__ = map_.next_value()?;
13802                        }
13803                        GeneratedField::SourceName => {
13804                            if source_name__.is_some() {
13805                                return Err(serde::de::Error::duplicate_field("sourceName"));
13806                            }
13807                            source_name__ = Some(map_.next_value()?);
13808                        }
13809                        GeneratedField::RateLimit => {
13810                            if rate_limit__.is_some() {
13811                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13812                            }
13813                            rate_limit__ = 
13814                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13815                            ;
13816                        }
13817                        GeneratedField::SecretRefs => {
13818                            if secret_refs__.is_some() {
13819                                return Err(serde::de::Error::duplicate_field("secretRefs"));
13820                            }
13821                            secret_refs__ = Some(
13822                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13823                            );
13824                        }
13825                    }
13826                }
13827                Ok(StreamSource {
13828                    source_id: source_id__.unwrap_or_default(),
13829                    state_table: state_table__,
13830                    row_id_index: row_id_index__,
13831                    columns: columns__.unwrap_or_default(),
13832                    with_properties: with_properties__.unwrap_or_default(),
13833                    info: info__,
13834                    source_name: source_name__.unwrap_or_default(),
13835                    rate_limit: rate_limit__,
13836                    secret_refs: secret_refs__.unwrap_or_default(),
13837                })
13838            }
13839        }
13840        deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13841    }
13842}
13843impl serde::Serialize for SubscriptionUpstreamInfo {
13844    #[allow(deprecated)]
13845    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13846    where
13847        S: serde::Serializer,
13848    {
13849        use serde::ser::SerializeStruct;
13850        let mut len = 0;
13851        if self.subscriber_id != 0 {
13852            len += 1;
13853        }
13854        if self.upstream_mv_table_id != 0 {
13855            len += 1;
13856        }
13857        let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13858        if self.subscriber_id != 0 {
13859            struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13860        }
13861        if self.upstream_mv_table_id != 0 {
13862            struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13863        }
13864        struct_ser.end()
13865    }
13866}
13867impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13868    #[allow(deprecated)]
13869    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13870    where
13871        D: serde::Deserializer<'de>,
13872    {
13873        const FIELDS: &[&str] = &[
13874            "subscriber_id",
13875            "subscriberId",
13876            "upstream_mv_table_id",
13877            "upstreamMvTableId",
13878        ];
13879
13880        #[allow(clippy::enum_variant_names)]
13881        enum GeneratedField {
13882            SubscriberId,
13883            UpstreamMvTableId,
13884        }
13885        impl<'de> serde::Deserialize<'de> for GeneratedField {
13886            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13887            where
13888                D: serde::Deserializer<'de>,
13889            {
13890                struct GeneratedVisitor;
13891
13892                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13893                    type Value = GeneratedField;
13894
13895                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13896                        write!(formatter, "expected one of: {:?}", &FIELDS)
13897                    }
13898
13899                    #[allow(unused_variables)]
13900                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13901                    where
13902                        E: serde::de::Error,
13903                    {
13904                        match value {
13905                            "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13906                            "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13907                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13908                        }
13909                    }
13910                }
13911                deserializer.deserialize_identifier(GeneratedVisitor)
13912            }
13913        }
13914        struct GeneratedVisitor;
13915        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13916            type Value = SubscriptionUpstreamInfo;
13917
13918            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13919                formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13920            }
13921
13922            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13923                where
13924                    V: serde::de::MapAccess<'de>,
13925            {
13926                let mut subscriber_id__ = None;
13927                let mut upstream_mv_table_id__ = None;
13928                while let Some(k) = map_.next_key()? {
13929                    match k {
13930                        GeneratedField::SubscriberId => {
13931                            if subscriber_id__.is_some() {
13932                                return Err(serde::de::Error::duplicate_field("subscriberId"));
13933                            }
13934                            subscriber_id__ = 
13935                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13936                            ;
13937                        }
13938                        GeneratedField::UpstreamMvTableId => {
13939                            if upstream_mv_table_id__.is_some() {
13940                                return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13941                            }
13942                            upstream_mv_table_id__ = 
13943                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13944                            ;
13945                        }
13946                    }
13947                }
13948                Ok(SubscriptionUpstreamInfo {
13949                    subscriber_id: subscriber_id__.unwrap_or_default(),
13950                    upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13951                })
13952            }
13953        }
13954        deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13955    }
13956}
13957impl serde::Serialize for SyncLogStoreNode {
13958    #[allow(deprecated)]
13959    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13960    where
13961        S: serde::Serializer,
13962    {
13963        use serde::ser::SerializeStruct;
13964        let mut len = 0;
13965        if self.log_store_table.is_some() {
13966            len += 1;
13967        }
13968        if self.pause_duration_ms != 0 {
13969            len += 1;
13970        }
13971        if self.buffer_size != 0 {
13972            len += 1;
13973        }
13974        if self.aligned {
13975            len += 1;
13976        }
13977        let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13978        if let Some(v) = self.log_store_table.as_ref() {
13979            struct_ser.serialize_field("logStoreTable", v)?;
13980        }
13981        if self.pause_duration_ms != 0 {
13982            struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13983        }
13984        if self.buffer_size != 0 {
13985            struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13986        }
13987        if self.aligned {
13988            struct_ser.serialize_field("aligned", &self.aligned)?;
13989        }
13990        struct_ser.end()
13991    }
13992}
13993impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13994    #[allow(deprecated)]
13995    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13996    where
13997        D: serde::Deserializer<'de>,
13998    {
13999        const FIELDS: &[&str] = &[
14000            "log_store_table",
14001            "logStoreTable",
14002            "pause_duration_ms",
14003            "pauseDurationMs",
14004            "buffer_size",
14005            "bufferSize",
14006            "aligned",
14007        ];
14008
14009        #[allow(clippy::enum_variant_names)]
14010        enum GeneratedField {
14011            LogStoreTable,
14012            PauseDurationMs,
14013            BufferSize,
14014            Aligned,
14015        }
14016        impl<'de> serde::Deserialize<'de> for GeneratedField {
14017            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14018            where
14019                D: serde::Deserializer<'de>,
14020            {
14021                struct GeneratedVisitor;
14022
14023                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14024                    type Value = GeneratedField;
14025
14026                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14027                        write!(formatter, "expected one of: {:?}", &FIELDS)
14028                    }
14029
14030                    #[allow(unused_variables)]
14031                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14032                    where
14033                        E: serde::de::Error,
14034                    {
14035                        match value {
14036                            "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
14037                            "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
14038                            "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
14039                            "aligned" => Ok(GeneratedField::Aligned),
14040                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14041                        }
14042                    }
14043                }
14044                deserializer.deserialize_identifier(GeneratedVisitor)
14045            }
14046        }
14047        struct GeneratedVisitor;
14048        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14049            type Value = SyncLogStoreNode;
14050
14051            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14052                formatter.write_str("struct stream_plan.SyncLogStoreNode")
14053            }
14054
14055            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
14056                where
14057                    V: serde::de::MapAccess<'de>,
14058            {
14059                let mut log_store_table__ = None;
14060                let mut pause_duration_ms__ = None;
14061                let mut buffer_size__ = None;
14062                let mut aligned__ = None;
14063                while let Some(k) = map_.next_key()? {
14064                    match k {
14065                        GeneratedField::LogStoreTable => {
14066                            if log_store_table__.is_some() {
14067                                return Err(serde::de::Error::duplicate_field("logStoreTable"));
14068                            }
14069                            log_store_table__ = map_.next_value()?;
14070                        }
14071                        GeneratedField::PauseDurationMs => {
14072                            if pause_duration_ms__.is_some() {
14073                                return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14074                            }
14075                            pause_duration_ms__ = 
14076                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14077                            ;
14078                        }
14079                        GeneratedField::BufferSize => {
14080                            if buffer_size__.is_some() {
14081                                return Err(serde::de::Error::duplicate_field("bufferSize"));
14082                            }
14083                            buffer_size__ = 
14084                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14085                            ;
14086                        }
14087                        GeneratedField::Aligned => {
14088                            if aligned__.is_some() {
14089                                return Err(serde::de::Error::duplicate_field("aligned"));
14090                            }
14091                            aligned__ = Some(map_.next_value()?);
14092                        }
14093                    }
14094                }
14095                Ok(SyncLogStoreNode {
14096                    log_store_table: log_store_table__,
14097                    pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14098                    buffer_size: buffer_size__.unwrap_or_default(),
14099                    aligned: aligned__.unwrap_or_default(),
14100                })
14101            }
14102        }
14103        deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14104    }
14105}
14106impl serde::Serialize for TemporalJoinNode {
14107    #[allow(deprecated)]
14108    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14109    where
14110        S: serde::Serializer,
14111    {
14112        use serde::ser::SerializeStruct;
14113        let mut len = 0;
14114        if self.join_type != 0 {
14115            len += 1;
14116        }
14117        if !self.left_key.is_empty() {
14118            len += 1;
14119        }
14120        if !self.right_key.is_empty() {
14121            len += 1;
14122        }
14123        if !self.null_safe.is_empty() {
14124            len += 1;
14125        }
14126        if self.condition.is_some() {
14127            len += 1;
14128        }
14129        if !self.output_indices.is_empty() {
14130            len += 1;
14131        }
14132        if self.table_desc.is_some() {
14133            len += 1;
14134        }
14135        if !self.table_output_indices.is_empty() {
14136            len += 1;
14137        }
14138        if self.memo_table.is_some() {
14139            len += 1;
14140        }
14141        if self.is_nested_loop {
14142            len += 1;
14143        }
14144        let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14145        if self.join_type != 0 {
14146            let v = super::plan_common::JoinType::try_from(self.join_type)
14147                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14148            struct_ser.serialize_field("joinType", &v)?;
14149        }
14150        if !self.left_key.is_empty() {
14151            struct_ser.serialize_field("leftKey", &self.left_key)?;
14152        }
14153        if !self.right_key.is_empty() {
14154            struct_ser.serialize_field("rightKey", &self.right_key)?;
14155        }
14156        if !self.null_safe.is_empty() {
14157            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14158        }
14159        if let Some(v) = self.condition.as_ref() {
14160            struct_ser.serialize_field("condition", v)?;
14161        }
14162        if !self.output_indices.is_empty() {
14163            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14164        }
14165        if let Some(v) = self.table_desc.as_ref() {
14166            struct_ser.serialize_field("tableDesc", v)?;
14167        }
14168        if !self.table_output_indices.is_empty() {
14169            struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14170        }
14171        if let Some(v) = self.memo_table.as_ref() {
14172            struct_ser.serialize_field("memoTable", v)?;
14173        }
14174        if self.is_nested_loop {
14175            struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14176        }
14177        struct_ser.end()
14178    }
14179}
14180impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14181    #[allow(deprecated)]
14182    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14183    where
14184        D: serde::Deserializer<'de>,
14185    {
14186        const FIELDS: &[&str] = &[
14187            "join_type",
14188            "joinType",
14189            "left_key",
14190            "leftKey",
14191            "right_key",
14192            "rightKey",
14193            "null_safe",
14194            "nullSafe",
14195            "condition",
14196            "output_indices",
14197            "outputIndices",
14198            "table_desc",
14199            "tableDesc",
14200            "table_output_indices",
14201            "tableOutputIndices",
14202            "memo_table",
14203            "memoTable",
14204            "is_nested_loop",
14205            "isNestedLoop",
14206        ];
14207
14208        #[allow(clippy::enum_variant_names)]
14209        enum GeneratedField {
14210            JoinType,
14211            LeftKey,
14212            RightKey,
14213            NullSafe,
14214            Condition,
14215            OutputIndices,
14216            TableDesc,
14217            TableOutputIndices,
14218            MemoTable,
14219            IsNestedLoop,
14220        }
14221        impl<'de> serde::Deserialize<'de> for GeneratedField {
14222            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14223            where
14224                D: serde::Deserializer<'de>,
14225            {
14226                struct GeneratedVisitor;
14227
14228                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14229                    type Value = GeneratedField;
14230
14231                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14232                        write!(formatter, "expected one of: {:?}", &FIELDS)
14233                    }
14234
14235                    #[allow(unused_variables)]
14236                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14237                    where
14238                        E: serde::de::Error,
14239                    {
14240                        match value {
14241                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14242                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14243                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14244                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14245                            "condition" => Ok(GeneratedField::Condition),
14246                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14247                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14248                            "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14249                            "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14250                            "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14251                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14252                        }
14253                    }
14254                }
14255                deserializer.deserialize_identifier(GeneratedVisitor)
14256            }
14257        }
14258        struct GeneratedVisitor;
14259        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14260            type Value = TemporalJoinNode;
14261
14262            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14263                formatter.write_str("struct stream_plan.TemporalJoinNode")
14264            }
14265
14266            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14267                where
14268                    V: serde::de::MapAccess<'de>,
14269            {
14270                let mut join_type__ = None;
14271                let mut left_key__ = None;
14272                let mut right_key__ = None;
14273                let mut null_safe__ = None;
14274                let mut condition__ = None;
14275                let mut output_indices__ = None;
14276                let mut table_desc__ = None;
14277                let mut table_output_indices__ = None;
14278                let mut memo_table__ = None;
14279                let mut is_nested_loop__ = None;
14280                while let Some(k) = map_.next_key()? {
14281                    match k {
14282                        GeneratedField::JoinType => {
14283                            if join_type__.is_some() {
14284                                return Err(serde::de::Error::duplicate_field("joinType"));
14285                            }
14286                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14287                        }
14288                        GeneratedField::LeftKey => {
14289                            if left_key__.is_some() {
14290                                return Err(serde::de::Error::duplicate_field("leftKey"));
14291                            }
14292                            left_key__ = 
14293                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14294                                    .into_iter().map(|x| x.0).collect())
14295                            ;
14296                        }
14297                        GeneratedField::RightKey => {
14298                            if right_key__.is_some() {
14299                                return Err(serde::de::Error::duplicate_field("rightKey"));
14300                            }
14301                            right_key__ = 
14302                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14303                                    .into_iter().map(|x| x.0).collect())
14304                            ;
14305                        }
14306                        GeneratedField::NullSafe => {
14307                            if null_safe__.is_some() {
14308                                return Err(serde::de::Error::duplicate_field("nullSafe"));
14309                            }
14310                            null_safe__ = Some(map_.next_value()?);
14311                        }
14312                        GeneratedField::Condition => {
14313                            if condition__.is_some() {
14314                                return Err(serde::de::Error::duplicate_field("condition"));
14315                            }
14316                            condition__ = map_.next_value()?;
14317                        }
14318                        GeneratedField::OutputIndices => {
14319                            if output_indices__.is_some() {
14320                                return Err(serde::de::Error::duplicate_field("outputIndices"));
14321                            }
14322                            output_indices__ = 
14323                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14324                                    .into_iter().map(|x| x.0).collect())
14325                            ;
14326                        }
14327                        GeneratedField::TableDesc => {
14328                            if table_desc__.is_some() {
14329                                return Err(serde::de::Error::duplicate_field("tableDesc"));
14330                            }
14331                            table_desc__ = map_.next_value()?;
14332                        }
14333                        GeneratedField::TableOutputIndices => {
14334                            if table_output_indices__.is_some() {
14335                                return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
14336                            }
14337                            table_output_indices__ = 
14338                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14339                                    .into_iter().map(|x| x.0).collect())
14340                            ;
14341                        }
14342                        GeneratedField::MemoTable => {
14343                            if memo_table__.is_some() {
14344                                return Err(serde::de::Error::duplicate_field("memoTable"));
14345                            }
14346                            memo_table__ = map_.next_value()?;
14347                        }
14348                        GeneratedField::IsNestedLoop => {
14349                            if is_nested_loop__.is_some() {
14350                                return Err(serde::de::Error::duplicate_field("isNestedLoop"));
14351                            }
14352                            is_nested_loop__ = Some(map_.next_value()?);
14353                        }
14354                    }
14355                }
14356                Ok(TemporalJoinNode {
14357                    join_type: join_type__.unwrap_or_default(),
14358                    left_key: left_key__.unwrap_or_default(),
14359                    right_key: right_key__.unwrap_or_default(),
14360                    null_safe: null_safe__.unwrap_or_default(),
14361                    condition: condition__,
14362                    output_indices: output_indices__.unwrap_or_default(),
14363                    table_desc: table_desc__,
14364                    table_output_indices: table_output_indices__.unwrap_or_default(),
14365                    memo_table: memo_table__,
14366                    is_nested_loop: is_nested_loop__.unwrap_or_default(),
14367                })
14368            }
14369        }
14370        deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
14371    }
14372}
14373impl serde::Serialize for ThrottleMutation {
14374    #[allow(deprecated)]
14375    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14376    where
14377        S: serde::Serializer,
14378    {
14379        use serde::ser::SerializeStruct;
14380        let mut len = 0;
14381        if !self.actor_throttle.is_empty() {
14382            len += 1;
14383        }
14384        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
14385        if !self.actor_throttle.is_empty() {
14386            struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
14387        }
14388        struct_ser.end()
14389    }
14390}
14391impl<'de> serde::Deserialize<'de> for ThrottleMutation {
14392    #[allow(deprecated)]
14393    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14394    where
14395        D: serde::Deserializer<'de>,
14396    {
14397        const FIELDS: &[&str] = &[
14398            "actor_throttle",
14399            "actorThrottle",
14400        ];
14401
14402        #[allow(clippy::enum_variant_names)]
14403        enum GeneratedField {
14404            ActorThrottle,
14405        }
14406        impl<'de> serde::Deserialize<'de> for GeneratedField {
14407            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14408            where
14409                D: serde::Deserializer<'de>,
14410            {
14411                struct GeneratedVisitor;
14412
14413                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14414                    type Value = GeneratedField;
14415
14416                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14417                        write!(formatter, "expected one of: {:?}", &FIELDS)
14418                    }
14419
14420                    #[allow(unused_variables)]
14421                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14422                    where
14423                        E: serde::de::Error,
14424                    {
14425                        match value {
14426                            "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
14427                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14428                        }
14429                    }
14430                }
14431                deserializer.deserialize_identifier(GeneratedVisitor)
14432            }
14433        }
14434        struct GeneratedVisitor;
14435        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14436            type Value = ThrottleMutation;
14437
14438            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14439                formatter.write_str("struct stream_plan.ThrottleMutation")
14440            }
14441
14442            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
14443                where
14444                    V: serde::de::MapAccess<'de>,
14445            {
14446                let mut actor_throttle__ = None;
14447                while let Some(k) = map_.next_key()? {
14448                    match k {
14449                        GeneratedField::ActorThrottle => {
14450                            if actor_throttle__.is_some() {
14451                                return Err(serde::de::Error::duplicate_field("actorThrottle"));
14452                            }
14453                            actor_throttle__ = Some(
14454                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14455                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14456                            );
14457                        }
14458                    }
14459                }
14460                Ok(ThrottleMutation {
14461                    actor_throttle: actor_throttle__.unwrap_or_default(),
14462                })
14463            }
14464        }
14465        deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
14466    }
14467}
14468impl serde::Serialize for throttle_mutation::RateLimit {
14469    #[allow(deprecated)]
14470    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14471    where
14472        S: serde::Serializer,
14473    {
14474        use serde::ser::SerializeStruct;
14475        let mut len = 0;
14476        if self.rate_limit.is_some() {
14477            len += 1;
14478        }
14479        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
14480        if let Some(v) = self.rate_limit.as_ref() {
14481            struct_ser.serialize_field("rateLimit", v)?;
14482        }
14483        struct_ser.end()
14484    }
14485}
14486impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
14487    #[allow(deprecated)]
14488    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14489    where
14490        D: serde::Deserializer<'de>,
14491    {
14492        const FIELDS: &[&str] = &[
14493            "rate_limit",
14494            "rateLimit",
14495        ];
14496
14497        #[allow(clippy::enum_variant_names)]
14498        enum GeneratedField {
14499            RateLimit,
14500        }
14501        impl<'de> serde::Deserialize<'de> for GeneratedField {
14502            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14503            where
14504                D: serde::Deserializer<'de>,
14505            {
14506                struct GeneratedVisitor;
14507
14508                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14509                    type Value = GeneratedField;
14510
14511                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14512                        write!(formatter, "expected one of: {:?}", &FIELDS)
14513                    }
14514
14515                    #[allow(unused_variables)]
14516                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14517                    where
14518                        E: serde::de::Error,
14519                    {
14520                        match value {
14521                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14522                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14523                        }
14524                    }
14525                }
14526                deserializer.deserialize_identifier(GeneratedVisitor)
14527            }
14528        }
14529        struct GeneratedVisitor;
14530        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14531            type Value = throttle_mutation::RateLimit;
14532
14533            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14534                formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
14535            }
14536
14537            fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
14538                where
14539                    V: serde::de::MapAccess<'de>,
14540            {
14541                let mut rate_limit__ = None;
14542                while let Some(k) = map_.next_key()? {
14543                    match k {
14544                        GeneratedField::RateLimit => {
14545                            if rate_limit__.is_some() {
14546                                return Err(serde::de::Error::duplicate_field("rateLimit"));
14547                            }
14548                            rate_limit__ = 
14549                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14550                            ;
14551                        }
14552                    }
14553                }
14554                Ok(throttle_mutation::RateLimit {
14555                    rate_limit: rate_limit__,
14556                })
14557            }
14558        }
14559        deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
14560    }
14561}
14562impl serde::Serialize for TopNNode {
14563    #[allow(deprecated)]
14564    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14565    where
14566        S: serde::Serializer,
14567    {
14568        use serde::ser::SerializeStruct;
14569        let mut len = 0;
14570        if self.limit != 0 {
14571            len += 1;
14572        }
14573        if self.offset != 0 {
14574            len += 1;
14575        }
14576        if self.table.is_some() {
14577            len += 1;
14578        }
14579        if !self.order_by.is_empty() {
14580            len += 1;
14581        }
14582        if self.with_ties {
14583            len += 1;
14584        }
14585        let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
14586        if self.limit != 0 {
14587            #[allow(clippy::needless_borrow)]
14588            #[allow(clippy::needless_borrows_for_generic_args)]
14589            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
14590        }
14591        if self.offset != 0 {
14592            #[allow(clippy::needless_borrow)]
14593            #[allow(clippy::needless_borrows_for_generic_args)]
14594            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
14595        }
14596        if let Some(v) = self.table.as_ref() {
14597            struct_ser.serialize_field("table", v)?;
14598        }
14599        if !self.order_by.is_empty() {
14600            struct_ser.serialize_field("orderBy", &self.order_by)?;
14601        }
14602        if self.with_ties {
14603            struct_ser.serialize_field("withTies", &self.with_ties)?;
14604        }
14605        struct_ser.end()
14606    }
14607}
14608impl<'de> serde::Deserialize<'de> for TopNNode {
14609    #[allow(deprecated)]
14610    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14611    where
14612        D: serde::Deserializer<'de>,
14613    {
14614        const FIELDS: &[&str] = &[
14615            "limit",
14616            "offset",
14617            "table",
14618            "order_by",
14619            "orderBy",
14620            "with_ties",
14621            "withTies",
14622        ];
14623
14624        #[allow(clippy::enum_variant_names)]
14625        enum GeneratedField {
14626            Limit,
14627            Offset,
14628            Table,
14629            OrderBy,
14630            WithTies,
14631        }
14632        impl<'de> serde::Deserialize<'de> for GeneratedField {
14633            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14634            where
14635                D: serde::Deserializer<'de>,
14636            {
14637                struct GeneratedVisitor;
14638
14639                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14640                    type Value = GeneratedField;
14641
14642                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14643                        write!(formatter, "expected one of: {:?}", &FIELDS)
14644                    }
14645
14646                    #[allow(unused_variables)]
14647                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14648                    where
14649                        E: serde::de::Error,
14650                    {
14651                        match value {
14652                            "limit" => Ok(GeneratedField::Limit),
14653                            "offset" => Ok(GeneratedField::Offset),
14654                            "table" => Ok(GeneratedField::Table),
14655                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
14656                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
14657                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14658                        }
14659                    }
14660                }
14661                deserializer.deserialize_identifier(GeneratedVisitor)
14662            }
14663        }
14664        struct GeneratedVisitor;
14665        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14666            type Value = TopNNode;
14667
14668            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14669                formatter.write_str("struct stream_plan.TopNNode")
14670            }
14671
14672            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
14673                where
14674                    V: serde::de::MapAccess<'de>,
14675            {
14676                let mut limit__ = None;
14677                let mut offset__ = None;
14678                let mut table__ = None;
14679                let mut order_by__ = None;
14680                let mut with_ties__ = None;
14681                while let Some(k) = map_.next_key()? {
14682                    match k {
14683                        GeneratedField::Limit => {
14684                            if limit__.is_some() {
14685                                return Err(serde::de::Error::duplicate_field("limit"));
14686                            }
14687                            limit__ = 
14688                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14689                            ;
14690                        }
14691                        GeneratedField::Offset => {
14692                            if offset__.is_some() {
14693                                return Err(serde::de::Error::duplicate_field("offset"));
14694                            }
14695                            offset__ = 
14696                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14697                            ;
14698                        }
14699                        GeneratedField::Table => {
14700                            if table__.is_some() {
14701                                return Err(serde::de::Error::duplicate_field("table"));
14702                            }
14703                            table__ = map_.next_value()?;
14704                        }
14705                        GeneratedField::OrderBy => {
14706                            if order_by__.is_some() {
14707                                return Err(serde::de::Error::duplicate_field("orderBy"));
14708                            }
14709                            order_by__ = Some(map_.next_value()?);
14710                        }
14711                        GeneratedField::WithTies => {
14712                            if with_ties__.is_some() {
14713                                return Err(serde::de::Error::duplicate_field("withTies"));
14714                            }
14715                            with_ties__ = Some(map_.next_value()?);
14716                        }
14717                    }
14718                }
14719                Ok(TopNNode {
14720                    limit: limit__.unwrap_or_default(),
14721                    offset: offset__.unwrap_or_default(),
14722                    table: table__,
14723                    order_by: order_by__.unwrap_or_default(),
14724                    with_ties: with_ties__.unwrap_or_default(),
14725                })
14726            }
14727        }
14728        deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14729    }
14730}
14731impl serde::Serialize for UnionNode {
14732    #[allow(deprecated)]
14733    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14734    where
14735        S: serde::Serializer,
14736    {
14737        use serde::ser::SerializeStruct;
14738        let len = 0;
14739        let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14740        struct_ser.end()
14741    }
14742}
14743impl<'de> serde::Deserialize<'de> for UnionNode {
14744    #[allow(deprecated)]
14745    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14746    where
14747        D: serde::Deserializer<'de>,
14748    {
14749        const FIELDS: &[&str] = &[
14750        ];
14751
14752        #[allow(clippy::enum_variant_names)]
14753        enum GeneratedField {
14754        }
14755        impl<'de> serde::Deserialize<'de> for GeneratedField {
14756            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14757            where
14758                D: serde::Deserializer<'de>,
14759            {
14760                struct GeneratedVisitor;
14761
14762                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14763                    type Value = GeneratedField;
14764
14765                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14766                        write!(formatter, "expected one of: {:?}", &FIELDS)
14767                    }
14768
14769                    #[allow(unused_variables)]
14770                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14771                    where
14772                        E: serde::de::Error,
14773                    {
14774                            Err(serde::de::Error::unknown_field(value, FIELDS))
14775                    }
14776                }
14777                deserializer.deserialize_identifier(GeneratedVisitor)
14778            }
14779        }
14780        struct GeneratedVisitor;
14781        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14782            type Value = UnionNode;
14783
14784            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14785                formatter.write_str("struct stream_plan.UnionNode")
14786            }
14787
14788            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14789                where
14790                    V: serde::de::MapAccess<'de>,
14791            {
14792                while map_.next_key::<GeneratedField>()?.is_some() {
14793                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14794                }
14795                Ok(UnionNode {
14796                })
14797            }
14798        }
14799        deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14800    }
14801}
14802impl serde::Serialize for UpdateMutation {
14803    #[allow(deprecated)]
14804    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14805    where
14806        S: serde::Serializer,
14807    {
14808        use serde::ser::SerializeStruct;
14809        let mut len = 0;
14810        if !self.dispatcher_update.is_empty() {
14811            len += 1;
14812        }
14813        if !self.merge_update.is_empty() {
14814            len += 1;
14815        }
14816        if !self.actor_vnode_bitmap_update.is_empty() {
14817            len += 1;
14818        }
14819        if !self.dropped_actors.is_empty() {
14820            len += 1;
14821        }
14822        if !self.actor_splits.is_empty() {
14823            len += 1;
14824        }
14825        if !self.actor_new_dispatchers.is_empty() {
14826            len += 1;
14827        }
14828        if self.actor_cdc_table_snapshot_splits.is_some() {
14829            len += 1;
14830        }
14831        if !self.sink_add_columns.is_empty() {
14832            len += 1;
14833        }
14834        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14835        if !self.dispatcher_update.is_empty() {
14836            struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14837        }
14838        if !self.merge_update.is_empty() {
14839            struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14840        }
14841        if !self.actor_vnode_bitmap_update.is_empty() {
14842            struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14843        }
14844        if !self.dropped_actors.is_empty() {
14845            struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14846        }
14847        if !self.actor_splits.is_empty() {
14848            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14849        }
14850        if !self.actor_new_dispatchers.is_empty() {
14851            struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14852        }
14853        if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
14854            struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
14855        }
14856        if !self.sink_add_columns.is_empty() {
14857            struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
14858        }
14859        struct_ser.end()
14860    }
14861}
14862impl<'de> serde::Deserialize<'de> for UpdateMutation {
14863    #[allow(deprecated)]
14864    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14865    where
14866        D: serde::Deserializer<'de>,
14867    {
14868        const FIELDS: &[&str] = &[
14869            "dispatcher_update",
14870            "dispatcherUpdate",
14871            "merge_update",
14872            "mergeUpdate",
14873            "actor_vnode_bitmap_update",
14874            "actorVnodeBitmapUpdate",
14875            "dropped_actors",
14876            "droppedActors",
14877            "actor_splits",
14878            "actorSplits",
14879            "actor_new_dispatchers",
14880            "actorNewDispatchers",
14881            "actor_cdc_table_snapshot_splits",
14882            "actorCdcTableSnapshotSplits",
14883            "sink_add_columns",
14884            "sinkAddColumns",
14885        ];
14886
14887        #[allow(clippy::enum_variant_names)]
14888        enum GeneratedField {
14889            DispatcherUpdate,
14890            MergeUpdate,
14891            ActorVnodeBitmapUpdate,
14892            DroppedActors,
14893            ActorSplits,
14894            ActorNewDispatchers,
14895            ActorCdcTableSnapshotSplits,
14896            SinkAddColumns,
14897        }
14898        impl<'de> serde::Deserialize<'de> for GeneratedField {
14899            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14900            where
14901                D: serde::Deserializer<'de>,
14902            {
14903                struct GeneratedVisitor;
14904
14905                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14906                    type Value = GeneratedField;
14907
14908                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14909                        write!(formatter, "expected one of: {:?}", &FIELDS)
14910                    }
14911
14912                    #[allow(unused_variables)]
14913                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14914                    where
14915                        E: serde::de::Error,
14916                    {
14917                        match value {
14918                            "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14919                            "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14920                            "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14921                            "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14922                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14923                            "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14924                            "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
14925                            "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
14926                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14927                        }
14928                    }
14929                }
14930                deserializer.deserialize_identifier(GeneratedVisitor)
14931            }
14932        }
14933        struct GeneratedVisitor;
14934        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14935            type Value = UpdateMutation;
14936
14937            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14938                formatter.write_str("struct stream_plan.UpdateMutation")
14939            }
14940
14941            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14942                where
14943                    V: serde::de::MapAccess<'de>,
14944            {
14945                let mut dispatcher_update__ = None;
14946                let mut merge_update__ = None;
14947                let mut actor_vnode_bitmap_update__ = None;
14948                let mut dropped_actors__ = None;
14949                let mut actor_splits__ = None;
14950                let mut actor_new_dispatchers__ = None;
14951                let mut actor_cdc_table_snapshot_splits__ = None;
14952                let mut sink_add_columns__ = None;
14953                while let Some(k) = map_.next_key()? {
14954                    match k {
14955                        GeneratedField::DispatcherUpdate => {
14956                            if dispatcher_update__.is_some() {
14957                                return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14958                            }
14959                            dispatcher_update__ = Some(map_.next_value()?);
14960                        }
14961                        GeneratedField::MergeUpdate => {
14962                            if merge_update__.is_some() {
14963                                return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14964                            }
14965                            merge_update__ = Some(map_.next_value()?);
14966                        }
14967                        GeneratedField::ActorVnodeBitmapUpdate => {
14968                            if actor_vnode_bitmap_update__.is_some() {
14969                                return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14970                            }
14971                            actor_vnode_bitmap_update__ = Some(
14972                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14973                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14974                            );
14975                        }
14976                        GeneratedField::DroppedActors => {
14977                            if dropped_actors__.is_some() {
14978                                return Err(serde::de::Error::duplicate_field("droppedActors"));
14979                            }
14980                            dropped_actors__ = 
14981                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14982                                    .into_iter().map(|x| x.0).collect())
14983                            ;
14984                        }
14985                        GeneratedField::ActorSplits => {
14986                            if actor_splits__.is_some() {
14987                                return Err(serde::de::Error::duplicate_field("actorSplits"));
14988                            }
14989                            actor_splits__ = Some(
14990                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14991                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14992                            );
14993                        }
14994                        GeneratedField::ActorNewDispatchers => {
14995                            if actor_new_dispatchers__.is_some() {
14996                                return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14997                            }
14998                            actor_new_dispatchers__ = Some(
14999                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15000                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15001                            );
15002                        }
15003                        GeneratedField::ActorCdcTableSnapshotSplits => {
15004                            if actor_cdc_table_snapshot_splits__.is_some() {
15005                                return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
15006                            }
15007                            actor_cdc_table_snapshot_splits__ = map_.next_value()?;
15008                        }
15009                        GeneratedField::SinkAddColumns => {
15010                            if sink_add_columns__.is_some() {
15011                                return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
15012                            }
15013                            sink_add_columns__ = Some(
15014                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15015                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15016                            );
15017                        }
15018                    }
15019                }
15020                Ok(UpdateMutation {
15021                    dispatcher_update: dispatcher_update__.unwrap_or_default(),
15022                    merge_update: merge_update__.unwrap_or_default(),
15023                    actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
15024                    dropped_actors: dropped_actors__.unwrap_or_default(),
15025                    actor_splits: actor_splits__.unwrap_or_default(),
15026                    actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
15027                    actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
15028                    sink_add_columns: sink_add_columns__.unwrap_or_default(),
15029                })
15030            }
15031        }
15032        deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
15033    }
15034}
15035impl serde::Serialize for update_mutation::DispatcherUpdate {
15036    #[allow(deprecated)]
15037    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15038    where
15039        S: serde::Serializer,
15040    {
15041        use serde::ser::SerializeStruct;
15042        let mut len = 0;
15043        if self.actor_id != 0 {
15044            len += 1;
15045        }
15046        if self.dispatcher_id != 0 {
15047            len += 1;
15048        }
15049        if self.hash_mapping.is_some() {
15050            len += 1;
15051        }
15052        if !self.added_downstream_actor_id.is_empty() {
15053            len += 1;
15054        }
15055        if !self.removed_downstream_actor_id.is_empty() {
15056            len += 1;
15057        }
15058        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15059        if self.actor_id != 0 {
15060            struct_ser.serialize_field("actorId", &self.actor_id)?;
15061        }
15062        if self.dispatcher_id != 0 {
15063            #[allow(clippy::needless_borrow)]
15064            #[allow(clippy::needless_borrows_for_generic_args)]
15065            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15066        }
15067        if let Some(v) = self.hash_mapping.as_ref() {
15068            struct_ser.serialize_field("hashMapping", v)?;
15069        }
15070        if !self.added_downstream_actor_id.is_empty() {
15071            struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15072        }
15073        if !self.removed_downstream_actor_id.is_empty() {
15074            struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15075        }
15076        struct_ser.end()
15077    }
15078}
15079impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15080    #[allow(deprecated)]
15081    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15082    where
15083        D: serde::Deserializer<'de>,
15084    {
15085        const FIELDS: &[&str] = &[
15086            "actor_id",
15087            "actorId",
15088            "dispatcher_id",
15089            "dispatcherId",
15090            "hash_mapping",
15091            "hashMapping",
15092            "added_downstream_actor_id",
15093            "addedDownstreamActorId",
15094            "removed_downstream_actor_id",
15095            "removedDownstreamActorId",
15096        ];
15097
15098        #[allow(clippy::enum_variant_names)]
15099        enum GeneratedField {
15100            ActorId,
15101            DispatcherId,
15102            HashMapping,
15103            AddedDownstreamActorId,
15104            RemovedDownstreamActorId,
15105        }
15106        impl<'de> serde::Deserialize<'de> for GeneratedField {
15107            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15108            where
15109                D: serde::Deserializer<'de>,
15110            {
15111                struct GeneratedVisitor;
15112
15113                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15114                    type Value = GeneratedField;
15115
15116                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15117                        write!(formatter, "expected one of: {:?}", &FIELDS)
15118                    }
15119
15120                    #[allow(unused_variables)]
15121                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15122                    where
15123                        E: serde::de::Error,
15124                    {
15125                        match value {
15126                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15127                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15128                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15129                            "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15130                            "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15131                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15132                        }
15133                    }
15134                }
15135                deserializer.deserialize_identifier(GeneratedVisitor)
15136            }
15137        }
15138        struct GeneratedVisitor;
15139        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15140            type Value = update_mutation::DispatcherUpdate;
15141
15142            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15143                formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15144            }
15145
15146            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15147                where
15148                    V: serde::de::MapAccess<'de>,
15149            {
15150                let mut actor_id__ = None;
15151                let mut dispatcher_id__ = None;
15152                let mut hash_mapping__ = None;
15153                let mut added_downstream_actor_id__ = None;
15154                let mut removed_downstream_actor_id__ = None;
15155                while let Some(k) = map_.next_key()? {
15156                    match k {
15157                        GeneratedField::ActorId => {
15158                            if actor_id__.is_some() {
15159                                return Err(serde::de::Error::duplicate_field("actorId"));
15160                            }
15161                            actor_id__ = 
15162                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15163                            ;
15164                        }
15165                        GeneratedField::DispatcherId => {
15166                            if dispatcher_id__.is_some() {
15167                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
15168                            }
15169                            dispatcher_id__ = 
15170                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15171                            ;
15172                        }
15173                        GeneratedField::HashMapping => {
15174                            if hash_mapping__.is_some() {
15175                                return Err(serde::de::Error::duplicate_field("hashMapping"));
15176                            }
15177                            hash_mapping__ = map_.next_value()?;
15178                        }
15179                        GeneratedField::AddedDownstreamActorId => {
15180                            if added_downstream_actor_id__.is_some() {
15181                                return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15182                            }
15183                            added_downstream_actor_id__ = 
15184                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15185                                    .into_iter().map(|x| x.0).collect())
15186                            ;
15187                        }
15188                        GeneratedField::RemovedDownstreamActorId => {
15189                            if removed_downstream_actor_id__.is_some() {
15190                                return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15191                            }
15192                            removed_downstream_actor_id__ = 
15193                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15194                                    .into_iter().map(|x| x.0).collect())
15195                            ;
15196                        }
15197                    }
15198                }
15199                Ok(update_mutation::DispatcherUpdate {
15200                    actor_id: actor_id__.unwrap_or_default(),
15201                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
15202                    hash_mapping: hash_mapping__,
15203                    added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15204                    removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15205                })
15206            }
15207        }
15208        deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15209    }
15210}
15211impl serde::Serialize for update_mutation::MergeUpdate {
15212    #[allow(deprecated)]
15213    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15214    where
15215        S: serde::Serializer,
15216    {
15217        use serde::ser::SerializeStruct;
15218        let mut len = 0;
15219        if self.actor_id != 0 {
15220            len += 1;
15221        }
15222        if self.upstream_fragment_id != 0 {
15223            len += 1;
15224        }
15225        if self.new_upstream_fragment_id.is_some() {
15226            len += 1;
15227        }
15228        if !self.added_upstream_actors.is_empty() {
15229            len += 1;
15230        }
15231        if !self.removed_upstream_actor_id.is_empty() {
15232            len += 1;
15233        }
15234        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15235        if self.actor_id != 0 {
15236            struct_ser.serialize_field("actorId", &self.actor_id)?;
15237        }
15238        if self.upstream_fragment_id != 0 {
15239            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15240        }
15241        if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15242            struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15243        }
15244        if !self.added_upstream_actors.is_empty() {
15245            struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15246        }
15247        if !self.removed_upstream_actor_id.is_empty() {
15248            struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15249        }
15250        struct_ser.end()
15251    }
15252}
15253impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15254    #[allow(deprecated)]
15255    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15256    where
15257        D: serde::Deserializer<'de>,
15258    {
15259        const FIELDS: &[&str] = &[
15260            "actor_id",
15261            "actorId",
15262            "upstream_fragment_id",
15263            "upstreamFragmentId",
15264            "new_upstream_fragment_id",
15265            "newUpstreamFragmentId",
15266            "added_upstream_actors",
15267            "addedUpstreamActors",
15268            "removed_upstream_actor_id",
15269            "removedUpstreamActorId",
15270        ];
15271
15272        #[allow(clippy::enum_variant_names)]
15273        enum GeneratedField {
15274            ActorId,
15275            UpstreamFragmentId,
15276            NewUpstreamFragmentId,
15277            AddedUpstreamActors,
15278            RemovedUpstreamActorId,
15279        }
15280        impl<'de> serde::Deserialize<'de> for GeneratedField {
15281            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15282            where
15283                D: serde::Deserializer<'de>,
15284            {
15285                struct GeneratedVisitor;
15286
15287                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15288                    type Value = GeneratedField;
15289
15290                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15291                        write!(formatter, "expected one of: {:?}", &FIELDS)
15292                    }
15293
15294                    #[allow(unused_variables)]
15295                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15296                    where
15297                        E: serde::de::Error,
15298                    {
15299                        match value {
15300                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15301                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15302                            "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
15303                            "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
15304                            "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
15305                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15306                        }
15307                    }
15308                }
15309                deserializer.deserialize_identifier(GeneratedVisitor)
15310            }
15311        }
15312        struct GeneratedVisitor;
15313        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15314            type Value = update_mutation::MergeUpdate;
15315
15316            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15317                formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
15318            }
15319
15320            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
15321                where
15322                    V: serde::de::MapAccess<'de>,
15323            {
15324                let mut actor_id__ = None;
15325                let mut upstream_fragment_id__ = None;
15326                let mut new_upstream_fragment_id__ = None;
15327                let mut added_upstream_actors__ = None;
15328                let mut removed_upstream_actor_id__ = None;
15329                while let Some(k) = map_.next_key()? {
15330                    match k {
15331                        GeneratedField::ActorId => {
15332                            if actor_id__.is_some() {
15333                                return Err(serde::de::Error::duplicate_field("actorId"));
15334                            }
15335                            actor_id__ = 
15336                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15337                            ;
15338                        }
15339                        GeneratedField::UpstreamFragmentId => {
15340                            if upstream_fragment_id__.is_some() {
15341                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15342                            }
15343                            upstream_fragment_id__ = 
15344                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15345                            ;
15346                        }
15347                        GeneratedField::NewUpstreamFragmentId => {
15348                            if new_upstream_fragment_id__.is_some() {
15349                                return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
15350                            }
15351                            new_upstream_fragment_id__ = 
15352                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15353                            ;
15354                        }
15355                        GeneratedField::AddedUpstreamActors => {
15356                            if added_upstream_actors__.is_some() {
15357                                return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
15358                            }
15359                            added_upstream_actors__ = Some(map_.next_value()?);
15360                        }
15361                        GeneratedField::RemovedUpstreamActorId => {
15362                            if removed_upstream_actor_id__.is_some() {
15363                                return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
15364                            }
15365                            removed_upstream_actor_id__ = 
15366                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15367                                    .into_iter().map(|x| x.0).collect())
15368                            ;
15369                        }
15370                    }
15371                }
15372                Ok(update_mutation::MergeUpdate {
15373                    actor_id: actor_id__.unwrap_or_default(),
15374                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15375                    new_upstream_fragment_id: new_upstream_fragment_id__,
15376                    added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
15377                    removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
15378                })
15379            }
15380        }
15381        deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
15382    }
15383}
15384impl serde::Serialize for UpstreamSinkInfo {
15385    #[allow(deprecated)]
15386    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15387    where
15388        S: serde::Serializer,
15389    {
15390        use serde::ser::SerializeStruct;
15391        let mut len = 0;
15392        if self.upstream_fragment_id != 0 {
15393            len += 1;
15394        }
15395        if !self.sink_output_schema.is_empty() {
15396            len += 1;
15397        }
15398        if !self.project_exprs.is_empty() {
15399            len += 1;
15400        }
15401        let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
15402        if self.upstream_fragment_id != 0 {
15403            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15404        }
15405        if !self.sink_output_schema.is_empty() {
15406            struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
15407        }
15408        if !self.project_exprs.is_empty() {
15409            struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
15410        }
15411        struct_ser.end()
15412    }
15413}
15414impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
15415    #[allow(deprecated)]
15416    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15417    where
15418        D: serde::Deserializer<'de>,
15419    {
15420        const FIELDS: &[&str] = &[
15421            "upstream_fragment_id",
15422            "upstreamFragmentId",
15423            "sink_output_schema",
15424            "sinkOutputSchema",
15425            "project_exprs",
15426            "projectExprs",
15427        ];
15428
15429        #[allow(clippy::enum_variant_names)]
15430        enum GeneratedField {
15431            UpstreamFragmentId,
15432            SinkOutputSchema,
15433            ProjectExprs,
15434        }
15435        impl<'de> serde::Deserialize<'de> for GeneratedField {
15436            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15437            where
15438                D: serde::Deserializer<'de>,
15439            {
15440                struct GeneratedVisitor;
15441
15442                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15443                    type Value = GeneratedField;
15444
15445                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15446                        write!(formatter, "expected one of: {:?}", &FIELDS)
15447                    }
15448
15449                    #[allow(unused_variables)]
15450                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15451                    where
15452                        E: serde::de::Error,
15453                    {
15454                        match value {
15455                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15456                            "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
15457                            "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
15458                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15459                        }
15460                    }
15461                }
15462                deserializer.deserialize_identifier(GeneratedVisitor)
15463            }
15464        }
15465        struct GeneratedVisitor;
15466        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15467            type Value = UpstreamSinkInfo;
15468
15469            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15470                formatter.write_str("struct stream_plan.UpstreamSinkInfo")
15471            }
15472
15473            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
15474                where
15475                    V: serde::de::MapAccess<'de>,
15476            {
15477                let mut upstream_fragment_id__ = None;
15478                let mut sink_output_schema__ = None;
15479                let mut project_exprs__ = None;
15480                while let Some(k) = map_.next_key()? {
15481                    match k {
15482                        GeneratedField::UpstreamFragmentId => {
15483                            if upstream_fragment_id__.is_some() {
15484                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15485                            }
15486                            upstream_fragment_id__ = 
15487                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15488                            ;
15489                        }
15490                        GeneratedField::SinkOutputSchema => {
15491                            if sink_output_schema__.is_some() {
15492                                return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
15493                            }
15494                            sink_output_schema__ = Some(map_.next_value()?);
15495                        }
15496                        GeneratedField::ProjectExprs => {
15497                            if project_exprs__.is_some() {
15498                                return Err(serde::de::Error::duplicate_field("projectExprs"));
15499                            }
15500                            project_exprs__ = Some(map_.next_value()?);
15501                        }
15502                    }
15503                }
15504                Ok(UpstreamSinkInfo {
15505                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15506                    sink_output_schema: sink_output_schema__.unwrap_or_default(),
15507                    project_exprs: project_exprs__.unwrap_or_default(),
15508                })
15509            }
15510        }
15511        deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
15512    }
15513}
15514impl serde::Serialize for UpstreamSinkUnionNode {
15515    #[allow(deprecated)]
15516    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15517    where
15518        S: serde::Serializer,
15519    {
15520        use serde::ser::SerializeStruct;
15521        let mut len = 0;
15522        if !self.init_upstreams.is_empty() {
15523            len += 1;
15524        }
15525        let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
15526        if !self.init_upstreams.is_empty() {
15527            struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
15528        }
15529        struct_ser.end()
15530    }
15531}
15532impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
15533    #[allow(deprecated)]
15534    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15535    where
15536        D: serde::Deserializer<'de>,
15537    {
15538        const FIELDS: &[&str] = &[
15539            "init_upstreams",
15540            "initUpstreams",
15541        ];
15542
15543        #[allow(clippy::enum_variant_names)]
15544        enum GeneratedField {
15545            InitUpstreams,
15546        }
15547        impl<'de> serde::Deserialize<'de> for GeneratedField {
15548            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15549            where
15550                D: serde::Deserializer<'de>,
15551            {
15552                struct GeneratedVisitor;
15553
15554                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15555                    type Value = GeneratedField;
15556
15557                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15558                        write!(formatter, "expected one of: {:?}", &FIELDS)
15559                    }
15560
15561                    #[allow(unused_variables)]
15562                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15563                    where
15564                        E: serde::de::Error,
15565                    {
15566                        match value {
15567                            "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
15568                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15569                        }
15570                    }
15571                }
15572                deserializer.deserialize_identifier(GeneratedVisitor)
15573            }
15574        }
15575        struct GeneratedVisitor;
15576        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15577            type Value = UpstreamSinkUnionNode;
15578
15579            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15580                formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
15581            }
15582
15583            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
15584                where
15585                    V: serde::de::MapAccess<'de>,
15586            {
15587                let mut init_upstreams__ = None;
15588                while let Some(k) = map_.next_key()? {
15589                    match k {
15590                        GeneratedField::InitUpstreams => {
15591                            if init_upstreams__.is_some() {
15592                                return Err(serde::de::Error::duplicate_field("initUpstreams"));
15593                            }
15594                            init_upstreams__ = Some(map_.next_value()?);
15595                        }
15596                    }
15597                }
15598                Ok(UpstreamSinkUnionNode {
15599                    init_upstreams: init_upstreams__.unwrap_or_default(),
15600                })
15601            }
15602        }
15603        deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
15604    }
15605}
15606impl serde::Serialize for ValuesNode {
15607    #[allow(deprecated)]
15608    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15609    where
15610        S: serde::Serializer,
15611    {
15612        use serde::ser::SerializeStruct;
15613        let mut len = 0;
15614        if !self.tuples.is_empty() {
15615            len += 1;
15616        }
15617        if !self.fields.is_empty() {
15618            len += 1;
15619        }
15620        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
15621        if !self.tuples.is_empty() {
15622            struct_ser.serialize_field("tuples", &self.tuples)?;
15623        }
15624        if !self.fields.is_empty() {
15625            struct_ser.serialize_field("fields", &self.fields)?;
15626        }
15627        struct_ser.end()
15628    }
15629}
15630impl<'de> serde::Deserialize<'de> for ValuesNode {
15631    #[allow(deprecated)]
15632    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15633    where
15634        D: serde::Deserializer<'de>,
15635    {
15636        const FIELDS: &[&str] = &[
15637            "tuples",
15638            "fields",
15639        ];
15640
15641        #[allow(clippy::enum_variant_names)]
15642        enum GeneratedField {
15643            Tuples,
15644            Fields,
15645        }
15646        impl<'de> serde::Deserialize<'de> for GeneratedField {
15647            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15648            where
15649                D: serde::Deserializer<'de>,
15650            {
15651                struct GeneratedVisitor;
15652
15653                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15654                    type Value = GeneratedField;
15655
15656                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15657                        write!(formatter, "expected one of: {:?}", &FIELDS)
15658                    }
15659
15660                    #[allow(unused_variables)]
15661                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15662                    where
15663                        E: serde::de::Error,
15664                    {
15665                        match value {
15666                            "tuples" => Ok(GeneratedField::Tuples),
15667                            "fields" => Ok(GeneratedField::Fields),
15668                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15669                        }
15670                    }
15671                }
15672                deserializer.deserialize_identifier(GeneratedVisitor)
15673            }
15674        }
15675        struct GeneratedVisitor;
15676        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15677            type Value = ValuesNode;
15678
15679            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15680                formatter.write_str("struct stream_plan.ValuesNode")
15681            }
15682
15683            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
15684                where
15685                    V: serde::de::MapAccess<'de>,
15686            {
15687                let mut tuples__ = None;
15688                let mut fields__ = None;
15689                while let Some(k) = map_.next_key()? {
15690                    match k {
15691                        GeneratedField::Tuples => {
15692                            if tuples__.is_some() {
15693                                return Err(serde::de::Error::duplicate_field("tuples"));
15694                            }
15695                            tuples__ = Some(map_.next_value()?);
15696                        }
15697                        GeneratedField::Fields => {
15698                            if fields__.is_some() {
15699                                return Err(serde::de::Error::duplicate_field("fields"));
15700                            }
15701                            fields__ = Some(map_.next_value()?);
15702                        }
15703                    }
15704                }
15705                Ok(ValuesNode {
15706                    tuples: tuples__.unwrap_or_default(),
15707                    fields: fields__.unwrap_or_default(),
15708                })
15709            }
15710        }
15711        deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
15712    }
15713}
15714impl serde::Serialize for values_node::ExprTuple {
15715    #[allow(deprecated)]
15716    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15717    where
15718        S: serde::Serializer,
15719    {
15720        use serde::ser::SerializeStruct;
15721        let mut len = 0;
15722        if !self.cells.is_empty() {
15723            len += 1;
15724        }
15725        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
15726        if !self.cells.is_empty() {
15727            struct_ser.serialize_field("cells", &self.cells)?;
15728        }
15729        struct_ser.end()
15730    }
15731}
15732impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
15733    #[allow(deprecated)]
15734    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15735    where
15736        D: serde::Deserializer<'de>,
15737    {
15738        const FIELDS: &[&str] = &[
15739            "cells",
15740        ];
15741
15742        #[allow(clippy::enum_variant_names)]
15743        enum GeneratedField {
15744            Cells,
15745        }
15746        impl<'de> serde::Deserialize<'de> for GeneratedField {
15747            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15748            where
15749                D: serde::Deserializer<'de>,
15750            {
15751                struct GeneratedVisitor;
15752
15753                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15754                    type Value = GeneratedField;
15755
15756                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15757                        write!(formatter, "expected one of: {:?}", &FIELDS)
15758                    }
15759
15760                    #[allow(unused_variables)]
15761                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15762                    where
15763                        E: serde::de::Error,
15764                    {
15765                        match value {
15766                            "cells" => Ok(GeneratedField::Cells),
15767                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15768                        }
15769                    }
15770                }
15771                deserializer.deserialize_identifier(GeneratedVisitor)
15772            }
15773        }
15774        struct GeneratedVisitor;
15775        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15776            type Value = values_node::ExprTuple;
15777
15778            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15779                formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
15780            }
15781
15782            fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
15783                where
15784                    V: serde::de::MapAccess<'de>,
15785            {
15786                let mut cells__ = None;
15787                while let Some(k) = map_.next_key()? {
15788                    match k {
15789                        GeneratedField::Cells => {
15790                            if cells__.is_some() {
15791                                return Err(serde::de::Error::duplicate_field("cells"));
15792                            }
15793                            cells__ = Some(map_.next_value()?);
15794                        }
15795                    }
15796                }
15797                Ok(values_node::ExprTuple {
15798                    cells: cells__.unwrap_or_default(),
15799                })
15800            }
15801        }
15802        deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
15803    }
15804}
15805impl serde::Serialize for VectorIndexWriteNode {
15806    #[allow(deprecated)]
15807    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15808    where
15809        S: serde::Serializer,
15810    {
15811        use serde::ser::SerializeStruct;
15812        let mut len = 0;
15813        if self.table.is_some() {
15814            len += 1;
15815        }
15816        let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
15817        if let Some(v) = self.table.as_ref() {
15818            struct_ser.serialize_field("table", v)?;
15819        }
15820        struct_ser.end()
15821    }
15822}
15823impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
15824    #[allow(deprecated)]
15825    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15826    where
15827        D: serde::Deserializer<'de>,
15828    {
15829        const FIELDS: &[&str] = &[
15830            "table",
15831        ];
15832
15833        #[allow(clippy::enum_variant_names)]
15834        enum GeneratedField {
15835            Table,
15836        }
15837        impl<'de> serde::Deserialize<'de> for GeneratedField {
15838            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15839            where
15840                D: serde::Deserializer<'de>,
15841            {
15842                struct GeneratedVisitor;
15843
15844                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15845                    type Value = GeneratedField;
15846
15847                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15848                        write!(formatter, "expected one of: {:?}", &FIELDS)
15849                    }
15850
15851                    #[allow(unused_variables)]
15852                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15853                    where
15854                        E: serde::de::Error,
15855                    {
15856                        match value {
15857                            "table" => Ok(GeneratedField::Table),
15858                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15859                        }
15860                    }
15861                }
15862                deserializer.deserialize_identifier(GeneratedVisitor)
15863            }
15864        }
15865        struct GeneratedVisitor;
15866        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15867            type Value = VectorIndexWriteNode;
15868
15869            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15870                formatter.write_str("struct stream_plan.VectorIndexWriteNode")
15871            }
15872
15873            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
15874                where
15875                    V: serde::de::MapAccess<'de>,
15876            {
15877                let mut table__ = None;
15878                while let Some(k) = map_.next_key()? {
15879                    match k {
15880                        GeneratedField::Table => {
15881                            if table__.is_some() {
15882                                return Err(serde::de::Error::duplicate_field("table"));
15883                            }
15884                            table__ = map_.next_value()?;
15885                        }
15886                    }
15887                }
15888                Ok(VectorIndexWriteNode {
15889                    table: table__,
15890                })
15891            }
15892        }
15893        deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
15894    }
15895}
15896impl serde::Serialize for Watermark {
15897    #[allow(deprecated)]
15898    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15899    where
15900        S: serde::Serializer,
15901    {
15902        use serde::ser::SerializeStruct;
15903        let mut len = 0;
15904        if self.column.is_some() {
15905            len += 1;
15906        }
15907        if self.val.is_some() {
15908            len += 1;
15909        }
15910        let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
15911        if let Some(v) = self.column.as_ref() {
15912            struct_ser.serialize_field("column", v)?;
15913        }
15914        if let Some(v) = self.val.as_ref() {
15915            struct_ser.serialize_field("val", v)?;
15916        }
15917        struct_ser.end()
15918    }
15919}
15920impl<'de> serde::Deserialize<'de> for Watermark {
15921    #[allow(deprecated)]
15922    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15923    where
15924        D: serde::Deserializer<'de>,
15925    {
15926        const FIELDS: &[&str] = &[
15927            "column",
15928            "val",
15929        ];
15930
15931        #[allow(clippy::enum_variant_names)]
15932        enum GeneratedField {
15933            Column,
15934            Val,
15935        }
15936        impl<'de> serde::Deserialize<'de> for GeneratedField {
15937            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15938            where
15939                D: serde::Deserializer<'de>,
15940            {
15941                struct GeneratedVisitor;
15942
15943                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15944                    type Value = GeneratedField;
15945
15946                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15947                        write!(formatter, "expected one of: {:?}", &FIELDS)
15948                    }
15949
15950                    #[allow(unused_variables)]
15951                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15952                    where
15953                        E: serde::de::Error,
15954                    {
15955                        match value {
15956                            "column" => Ok(GeneratedField::Column),
15957                            "val" => Ok(GeneratedField::Val),
15958                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15959                        }
15960                    }
15961                }
15962                deserializer.deserialize_identifier(GeneratedVisitor)
15963            }
15964        }
15965        struct GeneratedVisitor;
15966        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15967            type Value = Watermark;
15968
15969            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15970                formatter.write_str("struct stream_plan.Watermark")
15971            }
15972
15973            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
15974                where
15975                    V: serde::de::MapAccess<'de>,
15976            {
15977                let mut column__ = None;
15978                let mut val__ = None;
15979                while let Some(k) = map_.next_key()? {
15980                    match k {
15981                        GeneratedField::Column => {
15982                            if column__.is_some() {
15983                                return Err(serde::de::Error::duplicate_field("column"));
15984                            }
15985                            column__ = map_.next_value()?;
15986                        }
15987                        GeneratedField::Val => {
15988                            if val__.is_some() {
15989                                return Err(serde::de::Error::duplicate_field("val"));
15990                            }
15991                            val__ = map_.next_value()?;
15992                        }
15993                    }
15994                }
15995                Ok(Watermark {
15996                    column: column__,
15997                    val: val__,
15998                })
15999            }
16000        }
16001        deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
16002    }
16003}
16004impl serde::Serialize for WatermarkFilterNode {
16005    #[allow(deprecated)]
16006    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16007    where
16008        S: serde::Serializer,
16009    {
16010        use serde::ser::SerializeStruct;
16011        let mut len = 0;
16012        if !self.watermark_descs.is_empty() {
16013            len += 1;
16014        }
16015        if !self.tables.is_empty() {
16016            len += 1;
16017        }
16018        let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
16019        if !self.watermark_descs.is_empty() {
16020            struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
16021        }
16022        if !self.tables.is_empty() {
16023            struct_ser.serialize_field("tables", &self.tables)?;
16024        }
16025        struct_ser.end()
16026    }
16027}
16028impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
16029    #[allow(deprecated)]
16030    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16031    where
16032        D: serde::Deserializer<'de>,
16033    {
16034        const FIELDS: &[&str] = &[
16035            "watermark_descs",
16036            "watermarkDescs",
16037            "tables",
16038        ];
16039
16040        #[allow(clippy::enum_variant_names)]
16041        enum GeneratedField {
16042            WatermarkDescs,
16043            Tables,
16044        }
16045        impl<'de> serde::Deserialize<'de> for GeneratedField {
16046            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16047            where
16048                D: serde::Deserializer<'de>,
16049            {
16050                struct GeneratedVisitor;
16051
16052                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16053                    type Value = GeneratedField;
16054
16055                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16056                        write!(formatter, "expected one of: {:?}", &FIELDS)
16057                    }
16058
16059                    #[allow(unused_variables)]
16060                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16061                    where
16062                        E: serde::de::Error,
16063                    {
16064                        match value {
16065                            "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16066                            "tables" => Ok(GeneratedField::Tables),
16067                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16068                        }
16069                    }
16070                }
16071                deserializer.deserialize_identifier(GeneratedVisitor)
16072            }
16073        }
16074        struct GeneratedVisitor;
16075        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16076            type Value = WatermarkFilterNode;
16077
16078            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16079                formatter.write_str("struct stream_plan.WatermarkFilterNode")
16080            }
16081
16082            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16083                where
16084                    V: serde::de::MapAccess<'de>,
16085            {
16086                let mut watermark_descs__ = None;
16087                let mut tables__ = None;
16088                while let Some(k) = map_.next_key()? {
16089                    match k {
16090                        GeneratedField::WatermarkDescs => {
16091                            if watermark_descs__.is_some() {
16092                                return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16093                            }
16094                            watermark_descs__ = Some(map_.next_value()?);
16095                        }
16096                        GeneratedField::Tables => {
16097                            if tables__.is_some() {
16098                                return Err(serde::de::Error::duplicate_field("tables"));
16099                            }
16100                            tables__ = Some(map_.next_value()?);
16101                        }
16102                    }
16103                }
16104                Ok(WatermarkFilterNode {
16105                    watermark_descs: watermark_descs__.unwrap_or_default(),
16106                    tables: tables__.unwrap_or_default(),
16107                })
16108            }
16109        }
16110        deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16111    }
16112}