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 LocalityProviderNode {
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.locality_columns.is_empty() {
6409            len += 1;
6410        }
6411        if self.state_table.is_some() {
6412            len += 1;
6413        }
6414        if self.progress_table.is_some() {
6415            len += 1;
6416        }
6417        let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
6418        if !self.locality_columns.is_empty() {
6419            struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
6420        }
6421        if let Some(v) = self.state_table.as_ref() {
6422            struct_ser.serialize_field("stateTable", v)?;
6423        }
6424        if let Some(v) = self.progress_table.as_ref() {
6425            struct_ser.serialize_field("progressTable", v)?;
6426        }
6427        struct_ser.end()
6428    }
6429}
6430impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
6431    #[allow(deprecated)]
6432    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6433    where
6434        D: serde::Deserializer<'de>,
6435    {
6436        const FIELDS: &[&str] = &[
6437            "locality_columns",
6438            "localityColumns",
6439            "state_table",
6440            "stateTable",
6441            "progress_table",
6442            "progressTable",
6443        ];
6444
6445        #[allow(clippy::enum_variant_names)]
6446        enum GeneratedField {
6447            LocalityColumns,
6448            StateTable,
6449            ProgressTable,
6450        }
6451        impl<'de> serde::Deserialize<'de> for GeneratedField {
6452            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6453            where
6454                D: serde::Deserializer<'de>,
6455            {
6456                struct GeneratedVisitor;
6457
6458                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6459                    type Value = GeneratedField;
6460
6461                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6462                        write!(formatter, "expected one of: {:?}", &FIELDS)
6463                    }
6464
6465                    #[allow(unused_variables)]
6466                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6467                    where
6468                        E: serde::de::Error,
6469                    {
6470                        match value {
6471                            "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
6472                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6473                            "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
6474                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6475                        }
6476                    }
6477                }
6478                deserializer.deserialize_identifier(GeneratedVisitor)
6479            }
6480        }
6481        struct GeneratedVisitor;
6482        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6483            type Value = LocalityProviderNode;
6484
6485            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6486                formatter.write_str("struct stream_plan.LocalityProviderNode")
6487            }
6488
6489            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
6490                where
6491                    V: serde::de::MapAccess<'de>,
6492            {
6493                let mut locality_columns__ = None;
6494                let mut state_table__ = None;
6495                let mut progress_table__ = None;
6496                while let Some(k) = map_.next_key()? {
6497                    match k {
6498                        GeneratedField::LocalityColumns => {
6499                            if locality_columns__.is_some() {
6500                                return Err(serde::de::Error::duplicate_field("localityColumns"));
6501                            }
6502                            locality_columns__ = 
6503                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6504                                    .into_iter().map(|x| x.0).collect())
6505                            ;
6506                        }
6507                        GeneratedField::StateTable => {
6508                            if state_table__.is_some() {
6509                                return Err(serde::de::Error::duplicate_field("stateTable"));
6510                            }
6511                            state_table__ = map_.next_value()?;
6512                        }
6513                        GeneratedField::ProgressTable => {
6514                            if progress_table__.is_some() {
6515                                return Err(serde::de::Error::duplicate_field("progressTable"));
6516                            }
6517                            progress_table__ = map_.next_value()?;
6518                        }
6519                    }
6520                }
6521                Ok(LocalityProviderNode {
6522                    locality_columns: locality_columns__.unwrap_or_default(),
6523                    state_table: state_table__,
6524                    progress_table: progress_table__,
6525                })
6526            }
6527        }
6528        deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
6529    }
6530}
6531impl serde::Serialize for LookupNode {
6532    #[allow(deprecated)]
6533    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6534    where
6535        S: serde::Serializer,
6536    {
6537        use serde::ser::SerializeStruct;
6538        let mut len = 0;
6539        if !self.arrange_key.is_empty() {
6540            len += 1;
6541        }
6542        if !self.stream_key.is_empty() {
6543            len += 1;
6544        }
6545        if self.use_current_epoch {
6546            len += 1;
6547        }
6548        if !self.column_mapping.is_empty() {
6549            len += 1;
6550        }
6551        if self.arrangement_table_info.is_some() {
6552            len += 1;
6553        }
6554        if self.arrangement_table_id.is_some() {
6555            len += 1;
6556        }
6557        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6558        if !self.arrange_key.is_empty() {
6559            struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6560        }
6561        if !self.stream_key.is_empty() {
6562            struct_ser.serialize_field("streamKey", &self.stream_key)?;
6563        }
6564        if self.use_current_epoch {
6565            struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6566        }
6567        if !self.column_mapping.is_empty() {
6568            struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6569        }
6570        if let Some(v) = self.arrangement_table_info.as_ref() {
6571            struct_ser.serialize_field("arrangementTableInfo", v)?;
6572        }
6573        if let Some(v) = self.arrangement_table_id.as_ref() {
6574            match v {
6575                lookup_node::ArrangementTableId::TableId(v) => {
6576                    struct_ser.serialize_field("tableId", v)?;
6577                }
6578                lookup_node::ArrangementTableId::IndexId(v) => {
6579                    struct_ser.serialize_field("indexId", v)?;
6580                }
6581            }
6582        }
6583        struct_ser.end()
6584    }
6585}
6586impl<'de> serde::Deserialize<'de> for LookupNode {
6587    #[allow(deprecated)]
6588    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6589    where
6590        D: serde::Deserializer<'de>,
6591    {
6592        const FIELDS: &[&str] = &[
6593            "arrange_key",
6594            "arrangeKey",
6595            "stream_key",
6596            "streamKey",
6597            "use_current_epoch",
6598            "useCurrentEpoch",
6599            "column_mapping",
6600            "columnMapping",
6601            "arrangement_table_info",
6602            "arrangementTableInfo",
6603            "table_id",
6604            "tableId",
6605            "index_id",
6606            "indexId",
6607        ];
6608
6609        #[allow(clippy::enum_variant_names)]
6610        enum GeneratedField {
6611            ArrangeKey,
6612            StreamKey,
6613            UseCurrentEpoch,
6614            ColumnMapping,
6615            ArrangementTableInfo,
6616            TableId,
6617            IndexId,
6618        }
6619        impl<'de> serde::Deserialize<'de> for GeneratedField {
6620            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6621            where
6622                D: serde::Deserializer<'de>,
6623            {
6624                struct GeneratedVisitor;
6625
6626                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6627                    type Value = GeneratedField;
6628
6629                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6630                        write!(formatter, "expected one of: {:?}", &FIELDS)
6631                    }
6632
6633                    #[allow(unused_variables)]
6634                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6635                    where
6636                        E: serde::de::Error,
6637                    {
6638                        match value {
6639                            "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6640                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6641                            "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6642                            "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6643                            "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6644                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6645                            "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6646                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6647                        }
6648                    }
6649                }
6650                deserializer.deserialize_identifier(GeneratedVisitor)
6651            }
6652        }
6653        struct GeneratedVisitor;
6654        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6655            type Value = LookupNode;
6656
6657            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6658                formatter.write_str("struct stream_plan.LookupNode")
6659            }
6660
6661            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6662                where
6663                    V: serde::de::MapAccess<'de>,
6664            {
6665                let mut arrange_key__ = None;
6666                let mut stream_key__ = None;
6667                let mut use_current_epoch__ = None;
6668                let mut column_mapping__ = None;
6669                let mut arrangement_table_info__ = None;
6670                let mut arrangement_table_id__ = None;
6671                while let Some(k) = map_.next_key()? {
6672                    match k {
6673                        GeneratedField::ArrangeKey => {
6674                            if arrange_key__.is_some() {
6675                                return Err(serde::de::Error::duplicate_field("arrangeKey"));
6676                            }
6677                            arrange_key__ = 
6678                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6679                                    .into_iter().map(|x| x.0).collect())
6680                            ;
6681                        }
6682                        GeneratedField::StreamKey => {
6683                            if stream_key__.is_some() {
6684                                return Err(serde::de::Error::duplicate_field("streamKey"));
6685                            }
6686                            stream_key__ = 
6687                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6688                                    .into_iter().map(|x| x.0).collect())
6689                            ;
6690                        }
6691                        GeneratedField::UseCurrentEpoch => {
6692                            if use_current_epoch__.is_some() {
6693                                return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6694                            }
6695                            use_current_epoch__ = Some(map_.next_value()?);
6696                        }
6697                        GeneratedField::ColumnMapping => {
6698                            if column_mapping__.is_some() {
6699                                return Err(serde::de::Error::duplicate_field("columnMapping"));
6700                            }
6701                            column_mapping__ = 
6702                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6703                                    .into_iter().map(|x| x.0).collect())
6704                            ;
6705                        }
6706                        GeneratedField::ArrangementTableInfo => {
6707                            if arrangement_table_info__.is_some() {
6708                                return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6709                            }
6710                            arrangement_table_info__ = map_.next_value()?;
6711                        }
6712                        GeneratedField::TableId => {
6713                            if arrangement_table_id__.is_some() {
6714                                return Err(serde::de::Error::duplicate_field("tableId"));
6715                            }
6716                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6717                        }
6718                        GeneratedField::IndexId => {
6719                            if arrangement_table_id__.is_some() {
6720                                return Err(serde::de::Error::duplicate_field("indexId"));
6721                            }
6722                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6723                        }
6724                    }
6725                }
6726                Ok(LookupNode {
6727                    arrange_key: arrange_key__.unwrap_or_default(),
6728                    stream_key: stream_key__.unwrap_or_default(),
6729                    use_current_epoch: use_current_epoch__.unwrap_or_default(),
6730                    column_mapping: column_mapping__.unwrap_or_default(),
6731                    arrangement_table_info: arrangement_table_info__,
6732                    arrangement_table_id: arrangement_table_id__,
6733                })
6734            }
6735        }
6736        deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6737    }
6738}
6739impl serde::Serialize for LookupUnionNode {
6740    #[allow(deprecated)]
6741    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6742    where
6743        S: serde::Serializer,
6744    {
6745        use serde::ser::SerializeStruct;
6746        let mut len = 0;
6747        if !self.order.is_empty() {
6748            len += 1;
6749        }
6750        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6751        if !self.order.is_empty() {
6752            struct_ser.serialize_field("order", &self.order)?;
6753        }
6754        struct_ser.end()
6755    }
6756}
6757impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6758    #[allow(deprecated)]
6759    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6760    where
6761        D: serde::Deserializer<'de>,
6762    {
6763        const FIELDS: &[&str] = &[
6764            "order",
6765        ];
6766
6767        #[allow(clippy::enum_variant_names)]
6768        enum GeneratedField {
6769            Order,
6770        }
6771        impl<'de> serde::Deserialize<'de> for GeneratedField {
6772            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6773            where
6774                D: serde::Deserializer<'de>,
6775            {
6776                struct GeneratedVisitor;
6777
6778                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6779                    type Value = GeneratedField;
6780
6781                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6782                        write!(formatter, "expected one of: {:?}", &FIELDS)
6783                    }
6784
6785                    #[allow(unused_variables)]
6786                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6787                    where
6788                        E: serde::de::Error,
6789                    {
6790                        match value {
6791                            "order" => Ok(GeneratedField::Order),
6792                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6793                        }
6794                    }
6795                }
6796                deserializer.deserialize_identifier(GeneratedVisitor)
6797            }
6798        }
6799        struct GeneratedVisitor;
6800        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6801            type Value = LookupUnionNode;
6802
6803            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6804                formatter.write_str("struct stream_plan.LookupUnionNode")
6805            }
6806
6807            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6808                where
6809                    V: serde::de::MapAccess<'de>,
6810            {
6811                let mut order__ = None;
6812                while let Some(k) = map_.next_key()? {
6813                    match k {
6814                        GeneratedField::Order => {
6815                            if order__.is_some() {
6816                                return Err(serde::de::Error::duplicate_field("order"));
6817                            }
6818                            order__ = 
6819                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6820                                    .into_iter().map(|x| x.0).collect())
6821                            ;
6822                        }
6823                    }
6824                }
6825                Ok(LookupUnionNode {
6826                    order: order__.unwrap_or_default(),
6827                })
6828            }
6829        }
6830        deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6831    }
6832}
6833impl serde::Serialize for MaterializeNode {
6834    #[allow(deprecated)]
6835    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6836    where
6837        S: serde::Serializer,
6838    {
6839        use serde::ser::SerializeStruct;
6840        let mut len = 0;
6841        if self.table_id != 0 {
6842            len += 1;
6843        }
6844        if !self.column_orders.is_empty() {
6845            len += 1;
6846        }
6847        if self.table.is_some() {
6848            len += 1;
6849        }
6850        if self.staging_table.is_some() {
6851            len += 1;
6852        }
6853        if self.refresh_progress_table.is_some() {
6854            len += 1;
6855        }
6856        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6857        if self.table_id != 0 {
6858            struct_ser.serialize_field("tableId", &self.table_id)?;
6859        }
6860        if !self.column_orders.is_empty() {
6861            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6862        }
6863        if let Some(v) = self.table.as_ref() {
6864            struct_ser.serialize_field("table", v)?;
6865        }
6866        if let Some(v) = self.staging_table.as_ref() {
6867            struct_ser.serialize_field("stagingTable", v)?;
6868        }
6869        if let Some(v) = self.refresh_progress_table.as_ref() {
6870            struct_ser.serialize_field("refreshProgressTable", v)?;
6871        }
6872        struct_ser.end()
6873    }
6874}
6875impl<'de> serde::Deserialize<'de> for MaterializeNode {
6876    #[allow(deprecated)]
6877    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6878    where
6879        D: serde::Deserializer<'de>,
6880    {
6881        const FIELDS: &[&str] = &[
6882            "table_id",
6883            "tableId",
6884            "column_orders",
6885            "columnOrders",
6886            "table",
6887            "staging_table",
6888            "stagingTable",
6889            "refresh_progress_table",
6890            "refreshProgressTable",
6891        ];
6892
6893        #[allow(clippy::enum_variant_names)]
6894        enum GeneratedField {
6895            TableId,
6896            ColumnOrders,
6897            Table,
6898            StagingTable,
6899            RefreshProgressTable,
6900        }
6901        impl<'de> serde::Deserialize<'de> for GeneratedField {
6902            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6903            where
6904                D: serde::Deserializer<'de>,
6905            {
6906                struct GeneratedVisitor;
6907
6908                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6909                    type Value = GeneratedField;
6910
6911                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6912                        write!(formatter, "expected one of: {:?}", &FIELDS)
6913                    }
6914
6915                    #[allow(unused_variables)]
6916                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6917                    where
6918                        E: serde::de::Error,
6919                    {
6920                        match value {
6921                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6922                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6923                            "table" => Ok(GeneratedField::Table),
6924                            "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
6925                            "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
6926                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6927                        }
6928                    }
6929                }
6930                deserializer.deserialize_identifier(GeneratedVisitor)
6931            }
6932        }
6933        struct GeneratedVisitor;
6934        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6935            type Value = MaterializeNode;
6936
6937            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6938                formatter.write_str("struct stream_plan.MaterializeNode")
6939            }
6940
6941            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6942                where
6943                    V: serde::de::MapAccess<'de>,
6944            {
6945                let mut table_id__ = None;
6946                let mut column_orders__ = None;
6947                let mut table__ = None;
6948                let mut staging_table__ = None;
6949                let mut refresh_progress_table__ = None;
6950                while let Some(k) = map_.next_key()? {
6951                    match k {
6952                        GeneratedField::TableId => {
6953                            if table_id__.is_some() {
6954                                return Err(serde::de::Error::duplicate_field("tableId"));
6955                            }
6956                            table_id__ = 
6957                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6958                            ;
6959                        }
6960                        GeneratedField::ColumnOrders => {
6961                            if column_orders__.is_some() {
6962                                return Err(serde::de::Error::duplicate_field("columnOrders"));
6963                            }
6964                            column_orders__ = Some(map_.next_value()?);
6965                        }
6966                        GeneratedField::Table => {
6967                            if table__.is_some() {
6968                                return Err(serde::de::Error::duplicate_field("table"));
6969                            }
6970                            table__ = map_.next_value()?;
6971                        }
6972                        GeneratedField::StagingTable => {
6973                            if staging_table__.is_some() {
6974                                return Err(serde::de::Error::duplicate_field("stagingTable"));
6975                            }
6976                            staging_table__ = map_.next_value()?;
6977                        }
6978                        GeneratedField::RefreshProgressTable => {
6979                            if refresh_progress_table__.is_some() {
6980                                return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
6981                            }
6982                            refresh_progress_table__ = map_.next_value()?;
6983                        }
6984                    }
6985                }
6986                Ok(MaterializeNode {
6987                    table_id: table_id__.unwrap_or_default(),
6988                    column_orders: column_orders__.unwrap_or_default(),
6989                    table: table__,
6990                    staging_table: staging_table__,
6991                    refresh_progress_table: refresh_progress_table__,
6992                })
6993            }
6994        }
6995        deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6996    }
6997}
6998impl serde::Serialize for MaterializedExprsNode {
6999    #[allow(deprecated)]
7000    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7001    where
7002        S: serde::Serializer,
7003    {
7004        use serde::ser::SerializeStruct;
7005        let mut len = 0;
7006        if !self.exprs.is_empty() {
7007            len += 1;
7008        }
7009        if self.state_table.is_some() {
7010            len += 1;
7011        }
7012        if self.state_clean_col_idx.is_some() {
7013            len += 1;
7014        }
7015        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
7016        if !self.exprs.is_empty() {
7017            struct_ser.serialize_field("exprs", &self.exprs)?;
7018        }
7019        if let Some(v) = self.state_table.as_ref() {
7020            struct_ser.serialize_field("stateTable", v)?;
7021        }
7022        if let Some(v) = self.state_clean_col_idx.as_ref() {
7023            struct_ser.serialize_field("stateCleanColIdx", v)?;
7024        }
7025        struct_ser.end()
7026    }
7027}
7028impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
7029    #[allow(deprecated)]
7030    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7031    where
7032        D: serde::Deserializer<'de>,
7033    {
7034        const FIELDS: &[&str] = &[
7035            "exprs",
7036            "state_table",
7037            "stateTable",
7038            "state_clean_col_idx",
7039            "stateCleanColIdx",
7040        ];
7041
7042        #[allow(clippy::enum_variant_names)]
7043        enum GeneratedField {
7044            Exprs,
7045            StateTable,
7046            StateCleanColIdx,
7047        }
7048        impl<'de> serde::Deserialize<'de> for GeneratedField {
7049            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7050            where
7051                D: serde::Deserializer<'de>,
7052            {
7053                struct GeneratedVisitor;
7054
7055                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7056                    type Value = GeneratedField;
7057
7058                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7059                        write!(formatter, "expected one of: {:?}", &FIELDS)
7060                    }
7061
7062                    #[allow(unused_variables)]
7063                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7064                    where
7065                        E: serde::de::Error,
7066                    {
7067                        match value {
7068                            "exprs" => Ok(GeneratedField::Exprs),
7069                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7070                            "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
7071                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7072                        }
7073                    }
7074                }
7075                deserializer.deserialize_identifier(GeneratedVisitor)
7076            }
7077        }
7078        struct GeneratedVisitor;
7079        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7080            type Value = MaterializedExprsNode;
7081
7082            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7083                formatter.write_str("struct stream_plan.MaterializedExprsNode")
7084            }
7085
7086            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
7087                where
7088                    V: serde::de::MapAccess<'de>,
7089            {
7090                let mut exprs__ = None;
7091                let mut state_table__ = None;
7092                let mut state_clean_col_idx__ = None;
7093                while let Some(k) = map_.next_key()? {
7094                    match k {
7095                        GeneratedField::Exprs => {
7096                            if exprs__.is_some() {
7097                                return Err(serde::de::Error::duplicate_field("exprs"));
7098                            }
7099                            exprs__ = Some(map_.next_value()?);
7100                        }
7101                        GeneratedField::StateTable => {
7102                            if state_table__.is_some() {
7103                                return Err(serde::de::Error::duplicate_field("stateTable"));
7104                            }
7105                            state_table__ = map_.next_value()?;
7106                        }
7107                        GeneratedField::StateCleanColIdx => {
7108                            if state_clean_col_idx__.is_some() {
7109                                return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
7110                            }
7111                            state_clean_col_idx__ = 
7112                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7113                            ;
7114                        }
7115                    }
7116                }
7117                Ok(MaterializedExprsNode {
7118                    exprs: exprs__.unwrap_or_default(),
7119                    state_table: state_table__,
7120                    state_clean_col_idx: state_clean_col_idx__,
7121                })
7122            }
7123        }
7124        deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
7125    }
7126}
7127impl serde::Serialize for MergeNode {
7128    #[allow(deprecated)]
7129    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7130    where
7131        S: serde::Serializer,
7132    {
7133        use serde::ser::SerializeStruct;
7134        let mut len = 0;
7135        if !self.upstream_actor_id.is_empty() {
7136            len += 1;
7137        }
7138        if self.upstream_fragment_id != 0 {
7139            len += 1;
7140        }
7141        if self.upstream_dispatcher_type != 0 {
7142            len += 1;
7143        }
7144        if !self.fields.is_empty() {
7145            len += 1;
7146        }
7147        let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7148        if !self.upstream_actor_id.is_empty() {
7149            struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7150        }
7151        if self.upstream_fragment_id != 0 {
7152            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7153        }
7154        if self.upstream_dispatcher_type != 0 {
7155            let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7156                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7157            struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7158        }
7159        if !self.fields.is_empty() {
7160            struct_ser.serialize_field("fields", &self.fields)?;
7161        }
7162        struct_ser.end()
7163    }
7164}
7165impl<'de> serde::Deserialize<'de> for MergeNode {
7166    #[allow(deprecated)]
7167    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7168    where
7169        D: serde::Deserializer<'de>,
7170    {
7171        const FIELDS: &[&str] = &[
7172            "upstream_actor_id",
7173            "upstreamActorId",
7174            "upstream_fragment_id",
7175            "upstreamFragmentId",
7176            "upstream_dispatcher_type",
7177            "upstreamDispatcherType",
7178            "fields",
7179        ];
7180
7181        #[allow(clippy::enum_variant_names)]
7182        enum GeneratedField {
7183            UpstreamActorId,
7184            UpstreamFragmentId,
7185            UpstreamDispatcherType,
7186            Fields,
7187        }
7188        impl<'de> serde::Deserialize<'de> for GeneratedField {
7189            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7190            where
7191                D: serde::Deserializer<'de>,
7192            {
7193                struct GeneratedVisitor;
7194
7195                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7196                    type Value = GeneratedField;
7197
7198                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7199                        write!(formatter, "expected one of: {:?}", &FIELDS)
7200                    }
7201
7202                    #[allow(unused_variables)]
7203                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7204                    where
7205                        E: serde::de::Error,
7206                    {
7207                        match value {
7208                            "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7209                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7210                            "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7211                            "fields" => Ok(GeneratedField::Fields),
7212                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7213                        }
7214                    }
7215                }
7216                deserializer.deserialize_identifier(GeneratedVisitor)
7217            }
7218        }
7219        struct GeneratedVisitor;
7220        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7221            type Value = MergeNode;
7222
7223            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7224                formatter.write_str("struct stream_plan.MergeNode")
7225            }
7226
7227            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7228                where
7229                    V: serde::de::MapAccess<'de>,
7230            {
7231                let mut upstream_actor_id__ = None;
7232                let mut upstream_fragment_id__ = None;
7233                let mut upstream_dispatcher_type__ = None;
7234                let mut fields__ = None;
7235                while let Some(k) = map_.next_key()? {
7236                    match k {
7237                        GeneratedField::UpstreamActorId => {
7238                            if upstream_actor_id__.is_some() {
7239                                return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7240                            }
7241                            upstream_actor_id__ = 
7242                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7243                                    .into_iter().map(|x| x.0).collect())
7244                            ;
7245                        }
7246                        GeneratedField::UpstreamFragmentId => {
7247                            if upstream_fragment_id__.is_some() {
7248                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7249                            }
7250                            upstream_fragment_id__ = 
7251                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7252                            ;
7253                        }
7254                        GeneratedField::UpstreamDispatcherType => {
7255                            if upstream_dispatcher_type__.is_some() {
7256                                return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7257                            }
7258                            upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7259                        }
7260                        GeneratedField::Fields => {
7261                            if fields__.is_some() {
7262                                return Err(serde::de::Error::duplicate_field("fields"));
7263                            }
7264                            fields__ = Some(map_.next_value()?);
7265                        }
7266                    }
7267                }
7268                Ok(MergeNode {
7269                    upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7270                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7271                    upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7272                    fields: fields__.unwrap_or_default(),
7273                })
7274            }
7275        }
7276        deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7277    }
7278}
7279impl serde::Serialize for NoOpNode {
7280    #[allow(deprecated)]
7281    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7282    where
7283        S: serde::Serializer,
7284    {
7285        use serde::ser::SerializeStruct;
7286        let len = 0;
7287        let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7288        struct_ser.end()
7289    }
7290}
7291impl<'de> serde::Deserialize<'de> for NoOpNode {
7292    #[allow(deprecated)]
7293    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7294    where
7295        D: serde::Deserializer<'de>,
7296    {
7297        const FIELDS: &[&str] = &[
7298        ];
7299
7300        #[allow(clippy::enum_variant_names)]
7301        enum GeneratedField {
7302        }
7303        impl<'de> serde::Deserialize<'de> for GeneratedField {
7304            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7305            where
7306                D: serde::Deserializer<'de>,
7307            {
7308                struct GeneratedVisitor;
7309
7310                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7311                    type Value = GeneratedField;
7312
7313                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7314                        write!(formatter, "expected one of: {:?}", &FIELDS)
7315                    }
7316
7317                    #[allow(unused_variables)]
7318                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7319                    where
7320                        E: serde::de::Error,
7321                    {
7322                            Err(serde::de::Error::unknown_field(value, FIELDS))
7323                    }
7324                }
7325                deserializer.deserialize_identifier(GeneratedVisitor)
7326            }
7327        }
7328        struct GeneratedVisitor;
7329        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7330            type Value = NoOpNode;
7331
7332            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7333                formatter.write_str("struct stream_plan.NoOpNode")
7334            }
7335
7336            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7337                where
7338                    V: serde::de::MapAccess<'de>,
7339            {
7340                while map_.next_key::<GeneratedField>()?.is_some() {
7341                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7342                }
7343                Ok(NoOpNode {
7344                })
7345            }
7346        }
7347        deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7348    }
7349}
7350impl serde::Serialize for NowModeGenerateSeries {
7351    #[allow(deprecated)]
7352    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7353    where
7354        S: serde::Serializer,
7355    {
7356        use serde::ser::SerializeStruct;
7357        let mut len = 0;
7358        if self.start_timestamp.is_some() {
7359            len += 1;
7360        }
7361        if self.interval.is_some() {
7362            len += 1;
7363        }
7364        let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7365        if let Some(v) = self.start_timestamp.as_ref() {
7366            struct_ser.serialize_field("startTimestamp", v)?;
7367        }
7368        if let Some(v) = self.interval.as_ref() {
7369            struct_ser.serialize_field("interval", v)?;
7370        }
7371        struct_ser.end()
7372    }
7373}
7374impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7375    #[allow(deprecated)]
7376    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7377    where
7378        D: serde::Deserializer<'de>,
7379    {
7380        const FIELDS: &[&str] = &[
7381            "start_timestamp",
7382            "startTimestamp",
7383            "interval",
7384        ];
7385
7386        #[allow(clippy::enum_variant_names)]
7387        enum GeneratedField {
7388            StartTimestamp,
7389            Interval,
7390        }
7391        impl<'de> serde::Deserialize<'de> for GeneratedField {
7392            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7393            where
7394                D: serde::Deserializer<'de>,
7395            {
7396                struct GeneratedVisitor;
7397
7398                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7399                    type Value = GeneratedField;
7400
7401                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7402                        write!(formatter, "expected one of: {:?}", &FIELDS)
7403                    }
7404
7405                    #[allow(unused_variables)]
7406                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7407                    where
7408                        E: serde::de::Error,
7409                    {
7410                        match value {
7411                            "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7412                            "interval" => Ok(GeneratedField::Interval),
7413                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7414                        }
7415                    }
7416                }
7417                deserializer.deserialize_identifier(GeneratedVisitor)
7418            }
7419        }
7420        struct GeneratedVisitor;
7421        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7422            type Value = NowModeGenerateSeries;
7423
7424            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7425                formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7426            }
7427
7428            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7429                where
7430                    V: serde::de::MapAccess<'de>,
7431            {
7432                let mut start_timestamp__ = None;
7433                let mut interval__ = None;
7434                while let Some(k) = map_.next_key()? {
7435                    match k {
7436                        GeneratedField::StartTimestamp => {
7437                            if start_timestamp__.is_some() {
7438                                return Err(serde::de::Error::duplicate_field("startTimestamp"));
7439                            }
7440                            start_timestamp__ = map_.next_value()?;
7441                        }
7442                        GeneratedField::Interval => {
7443                            if interval__.is_some() {
7444                                return Err(serde::de::Error::duplicate_field("interval"));
7445                            }
7446                            interval__ = map_.next_value()?;
7447                        }
7448                    }
7449                }
7450                Ok(NowModeGenerateSeries {
7451                    start_timestamp: start_timestamp__,
7452                    interval: interval__,
7453                })
7454            }
7455        }
7456        deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7457    }
7458}
7459impl serde::Serialize for NowModeUpdateCurrent {
7460    #[allow(deprecated)]
7461    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7462    where
7463        S: serde::Serializer,
7464    {
7465        use serde::ser::SerializeStruct;
7466        let len = 0;
7467        let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7468        struct_ser.end()
7469    }
7470}
7471impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7472    #[allow(deprecated)]
7473    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7474    where
7475        D: serde::Deserializer<'de>,
7476    {
7477        const FIELDS: &[&str] = &[
7478        ];
7479
7480        #[allow(clippy::enum_variant_names)]
7481        enum GeneratedField {
7482        }
7483        impl<'de> serde::Deserialize<'de> for GeneratedField {
7484            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7485            where
7486                D: serde::Deserializer<'de>,
7487            {
7488                struct GeneratedVisitor;
7489
7490                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7491                    type Value = GeneratedField;
7492
7493                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7494                        write!(formatter, "expected one of: {:?}", &FIELDS)
7495                    }
7496
7497                    #[allow(unused_variables)]
7498                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7499                    where
7500                        E: serde::de::Error,
7501                    {
7502                            Err(serde::de::Error::unknown_field(value, FIELDS))
7503                    }
7504                }
7505                deserializer.deserialize_identifier(GeneratedVisitor)
7506            }
7507        }
7508        struct GeneratedVisitor;
7509        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7510            type Value = NowModeUpdateCurrent;
7511
7512            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7513                formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7514            }
7515
7516            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7517                where
7518                    V: serde::de::MapAccess<'de>,
7519            {
7520                while map_.next_key::<GeneratedField>()?.is_some() {
7521                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7522                }
7523                Ok(NowModeUpdateCurrent {
7524                })
7525            }
7526        }
7527        deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7528    }
7529}
7530impl serde::Serialize for NowNode {
7531    #[allow(deprecated)]
7532    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7533    where
7534        S: serde::Serializer,
7535    {
7536        use serde::ser::SerializeStruct;
7537        let mut len = 0;
7538        if self.state_table.is_some() {
7539            len += 1;
7540        }
7541        if self.mode.is_some() {
7542            len += 1;
7543        }
7544        let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7545        if let Some(v) = self.state_table.as_ref() {
7546            struct_ser.serialize_field("stateTable", v)?;
7547        }
7548        if let Some(v) = self.mode.as_ref() {
7549            match v {
7550                now_node::Mode::UpdateCurrent(v) => {
7551                    struct_ser.serialize_field("updateCurrent", v)?;
7552                }
7553                now_node::Mode::GenerateSeries(v) => {
7554                    struct_ser.serialize_field("generateSeries", v)?;
7555                }
7556            }
7557        }
7558        struct_ser.end()
7559    }
7560}
7561impl<'de> serde::Deserialize<'de> for NowNode {
7562    #[allow(deprecated)]
7563    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7564    where
7565        D: serde::Deserializer<'de>,
7566    {
7567        const FIELDS: &[&str] = &[
7568            "state_table",
7569            "stateTable",
7570            "update_current",
7571            "updateCurrent",
7572            "generate_series",
7573            "generateSeries",
7574        ];
7575
7576        #[allow(clippy::enum_variant_names)]
7577        enum GeneratedField {
7578            StateTable,
7579            UpdateCurrent,
7580            GenerateSeries,
7581        }
7582        impl<'de> serde::Deserialize<'de> for GeneratedField {
7583            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7584            where
7585                D: serde::Deserializer<'de>,
7586            {
7587                struct GeneratedVisitor;
7588
7589                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7590                    type Value = GeneratedField;
7591
7592                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7593                        write!(formatter, "expected one of: {:?}", &FIELDS)
7594                    }
7595
7596                    #[allow(unused_variables)]
7597                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7598                    where
7599                        E: serde::de::Error,
7600                    {
7601                        match value {
7602                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7603                            "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7604                            "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7605                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7606                        }
7607                    }
7608                }
7609                deserializer.deserialize_identifier(GeneratedVisitor)
7610            }
7611        }
7612        struct GeneratedVisitor;
7613        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7614            type Value = NowNode;
7615
7616            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7617                formatter.write_str("struct stream_plan.NowNode")
7618            }
7619
7620            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7621                where
7622                    V: serde::de::MapAccess<'de>,
7623            {
7624                let mut state_table__ = None;
7625                let mut mode__ = None;
7626                while let Some(k) = map_.next_key()? {
7627                    match k {
7628                        GeneratedField::StateTable => {
7629                            if state_table__.is_some() {
7630                                return Err(serde::de::Error::duplicate_field("stateTable"));
7631                            }
7632                            state_table__ = map_.next_value()?;
7633                        }
7634                        GeneratedField::UpdateCurrent => {
7635                            if mode__.is_some() {
7636                                return Err(serde::de::Error::duplicate_field("updateCurrent"));
7637                            }
7638                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7639;
7640                        }
7641                        GeneratedField::GenerateSeries => {
7642                            if mode__.is_some() {
7643                                return Err(serde::de::Error::duplicate_field("generateSeries"));
7644                            }
7645                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7646;
7647                        }
7648                    }
7649                }
7650                Ok(NowNode {
7651                    state_table: state_table__,
7652                    mode: mode__,
7653                })
7654            }
7655        }
7656        deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7657    }
7658}
7659impl serde::Serialize for OverWindowCachePolicy {
7660    #[allow(deprecated)]
7661    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7662    where
7663        S: serde::Serializer,
7664    {
7665        let variant = match self {
7666            Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7667            Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7668            Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7669            Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7670            Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7671        };
7672        serializer.serialize_str(variant)
7673    }
7674}
7675impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7676    #[allow(deprecated)]
7677    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7678    where
7679        D: serde::Deserializer<'de>,
7680    {
7681        const FIELDS: &[&str] = &[
7682            "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7683            "OVER_WINDOW_CACHE_POLICY_FULL",
7684            "OVER_WINDOW_CACHE_POLICY_RECENT",
7685            "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7686            "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7687        ];
7688
7689        struct GeneratedVisitor;
7690
7691        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7692            type Value = OverWindowCachePolicy;
7693
7694            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7695                write!(formatter, "expected one of: {:?}", &FIELDS)
7696            }
7697
7698            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7699            where
7700                E: serde::de::Error,
7701            {
7702                i32::try_from(v)
7703                    .ok()
7704                    .and_then(|x| x.try_into().ok())
7705                    .ok_or_else(|| {
7706                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7707                    })
7708            }
7709
7710            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7711            where
7712                E: serde::de::Error,
7713            {
7714                i32::try_from(v)
7715                    .ok()
7716                    .and_then(|x| x.try_into().ok())
7717                    .ok_or_else(|| {
7718                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7719                    })
7720            }
7721
7722            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7723            where
7724                E: serde::de::Error,
7725            {
7726                match value {
7727                    "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7728                    "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7729                    "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7730                    "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7731                    "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7732                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7733                }
7734            }
7735        }
7736        deserializer.deserialize_any(GeneratedVisitor)
7737    }
7738}
7739impl serde::Serialize for OverWindowNode {
7740    #[allow(deprecated)]
7741    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7742    where
7743        S: serde::Serializer,
7744    {
7745        use serde::ser::SerializeStruct;
7746        let mut len = 0;
7747        if !self.calls.is_empty() {
7748            len += 1;
7749        }
7750        if !self.partition_by.is_empty() {
7751            len += 1;
7752        }
7753        if !self.order_by.is_empty() {
7754            len += 1;
7755        }
7756        if self.state_table.is_some() {
7757            len += 1;
7758        }
7759        if self.cache_policy != 0 {
7760            len += 1;
7761        }
7762        let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7763        if !self.calls.is_empty() {
7764            struct_ser.serialize_field("calls", &self.calls)?;
7765        }
7766        if !self.partition_by.is_empty() {
7767            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7768        }
7769        if !self.order_by.is_empty() {
7770            struct_ser.serialize_field("orderBy", &self.order_by)?;
7771        }
7772        if let Some(v) = self.state_table.as_ref() {
7773            struct_ser.serialize_field("stateTable", v)?;
7774        }
7775        if self.cache_policy != 0 {
7776            let v = OverWindowCachePolicy::try_from(self.cache_policy)
7777                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7778            struct_ser.serialize_field("cachePolicy", &v)?;
7779        }
7780        struct_ser.end()
7781    }
7782}
7783impl<'de> serde::Deserialize<'de> for OverWindowNode {
7784    #[allow(deprecated)]
7785    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7786    where
7787        D: serde::Deserializer<'de>,
7788    {
7789        const FIELDS: &[&str] = &[
7790            "calls",
7791            "partition_by",
7792            "partitionBy",
7793            "order_by",
7794            "orderBy",
7795            "state_table",
7796            "stateTable",
7797            "cache_policy",
7798            "cachePolicy",
7799        ];
7800
7801        #[allow(clippy::enum_variant_names)]
7802        enum GeneratedField {
7803            Calls,
7804            PartitionBy,
7805            OrderBy,
7806            StateTable,
7807            CachePolicy,
7808        }
7809        impl<'de> serde::Deserialize<'de> for GeneratedField {
7810            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7811            where
7812                D: serde::Deserializer<'de>,
7813            {
7814                struct GeneratedVisitor;
7815
7816                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7817                    type Value = GeneratedField;
7818
7819                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7820                        write!(formatter, "expected one of: {:?}", &FIELDS)
7821                    }
7822
7823                    #[allow(unused_variables)]
7824                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7825                    where
7826                        E: serde::de::Error,
7827                    {
7828                        match value {
7829                            "calls" => Ok(GeneratedField::Calls),
7830                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7831                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7832                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7833                            "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7834                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7835                        }
7836                    }
7837                }
7838                deserializer.deserialize_identifier(GeneratedVisitor)
7839            }
7840        }
7841        struct GeneratedVisitor;
7842        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7843            type Value = OverWindowNode;
7844
7845            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7846                formatter.write_str("struct stream_plan.OverWindowNode")
7847            }
7848
7849            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7850                where
7851                    V: serde::de::MapAccess<'de>,
7852            {
7853                let mut calls__ = None;
7854                let mut partition_by__ = None;
7855                let mut order_by__ = None;
7856                let mut state_table__ = None;
7857                let mut cache_policy__ = None;
7858                while let Some(k) = map_.next_key()? {
7859                    match k {
7860                        GeneratedField::Calls => {
7861                            if calls__.is_some() {
7862                                return Err(serde::de::Error::duplicate_field("calls"));
7863                            }
7864                            calls__ = Some(map_.next_value()?);
7865                        }
7866                        GeneratedField::PartitionBy => {
7867                            if partition_by__.is_some() {
7868                                return Err(serde::de::Error::duplicate_field("partitionBy"));
7869                            }
7870                            partition_by__ = 
7871                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7872                                    .into_iter().map(|x| x.0).collect())
7873                            ;
7874                        }
7875                        GeneratedField::OrderBy => {
7876                            if order_by__.is_some() {
7877                                return Err(serde::de::Error::duplicate_field("orderBy"));
7878                            }
7879                            order_by__ = Some(map_.next_value()?);
7880                        }
7881                        GeneratedField::StateTable => {
7882                            if state_table__.is_some() {
7883                                return Err(serde::de::Error::duplicate_field("stateTable"));
7884                            }
7885                            state_table__ = map_.next_value()?;
7886                        }
7887                        GeneratedField::CachePolicy => {
7888                            if cache_policy__.is_some() {
7889                                return Err(serde::de::Error::duplicate_field("cachePolicy"));
7890                            }
7891                            cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7892                        }
7893                    }
7894                }
7895                Ok(OverWindowNode {
7896                    calls: calls__.unwrap_or_default(),
7897                    partition_by: partition_by__.unwrap_or_default(),
7898                    order_by: order_by__.unwrap_or_default(),
7899                    state_table: state_table__,
7900                    cache_policy: cache_policy__.unwrap_or_default(),
7901                })
7902            }
7903        }
7904        deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7905    }
7906}
7907impl serde::Serialize for PauseMutation {
7908    #[allow(deprecated)]
7909    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7910    where
7911        S: serde::Serializer,
7912    {
7913        use serde::ser::SerializeStruct;
7914        let len = 0;
7915        let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7916        struct_ser.end()
7917    }
7918}
7919impl<'de> serde::Deserialize<'de> for PauseMutation {
7920    #[allow(deprecated)]
7921    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7922    where
7923        D: serde::Deserializer<'de>,
7924    {
7925        const FIELDS: &[&str] = &[
7926        ];
7927
7928        #[allow(clippy::enum_variant_names)]
7929        enum GeneratedField {
7930        }
7931        impl<'de> serde::Deserialize<'de> for GeneratedField {
7932            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7933            where
7934                D: serde::Deserializer<'de>,
7935            {
7936                struct GeneratedVisitor;
7937
7938                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7939                    type Value = GeneratedField;
7940
7941                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7942                        write!(formatter, "expected one of: {:?}", &FIELDS)
7943                    }
7944
7945                    #[allow(unused_variables)]
7946                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7947                    where
7948                        E: serde::de::Error,
7949                    {
7950                            Err(serde::de::Error::unknown_field(value, FIELDS))
7951                    }
7952                }
7953                deserializer.deserialize_identifier(GeneratedVisitor)
7954            }
7955        }
7956        struct GeneratedVisitor;
7957        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7958            type Value = PauseMutation;
7959
7960            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7961                formatter.write_str("struct stream_plan.PauseMutation")
7962            }
7963
7964            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7965                where
7966                    V: serde::de::MapAccess<'de>,
7967            {
7968                while map_.next_key::<GeneratedField>()?.is_some() {
7969                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7970                }
7971                Ok(PauseMutation {
7972                })
7973            }
7974        }
7975        deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7976    }
7977}
7978impl serde::Serialize for ProjectNode {
7979    #[allow(deprecated)]
7980    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7981    where
7982        S: serde::Serializer,
7983    {
7984        use serde::ser::SerializeStruct;
7985        let mut len = 0;
7986        if !self.select_list.is_empty() {
7987            len += 1;
7988        }
7989        if !self.watermark_input_cols.is_empty() {
7990            len += 1;
7991        }
7992        if !self.watermark_output_cols.is_empty() {
7993            len += 1;
7994        }
7995        if !self.nondecreasing_exprs.is_empty() {
7996            len += 1;
7997        }
7998        if self.noop_update_hint {
7999            len += 1;
8000        }
8001        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
8002        if !self.select_list.is_empty() {
8003            struct_ser.serialize_field("selectList", &self.select_list)?;
8004        }
8005        if !self.watermark_input_cols.is_empty() {
8006            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8007        }
8008        if !self.watermark_output_cols.is_empty() {
8009            struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
8010        }
8011        if !self.nondecreasing_exprs.is_empty() {
8012            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8013        }
8014        if self.noop_update_hint {
8015            struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
8016        }
8017        struct_ser.end()
8018    }
8019}
8020impl<'de> serde::Deserialize<'de> for ProjectNode {
8021    #[allow(deprecated)]
8022    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8023    where
8024        D: serde::Deserializer<'de>,
8025    {
8026        const FIELDS: &[&str] = &[
8027            "select_list",
8028            "selectList",
8029            "watermark_input_cols",
8030            "watermarkInputCols",
8031            "watermark_output_cols",
8032            "watermarkOutputCols",
8033            "nondecreasing_exprs",
8034            "nondecreasingExprs",
8035            "noop_update_hint",
8036            "noopUpdateHint",
8037        ];
8038
8039        #[allow(clippy::enum_variant_names)]
8040        enum GeneratedField {
8041            SelectList,
8042            WatermarkInputCols,
8043            WatermarkOutputCols,
8044            NondecreasingExprs,
8045            NoopUpdateHint,
8046        }
8047        impl<'de> serde::Deserialize<'de> for GeneratedField {
8048            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8049            where
8050                D: serde::Deserializer<'de>,
8051            {
8052                struct GeneratedVisitor;
8053
8054                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8055                    type Value = GeneratedField;
8056
8057                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8058                        write!(formatter, "expected one of: {:?}", &FIELDS)
8059                    }
8060
8061                    #[allow(unused_variables)]
8062                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8063                    where
8064                        E: serde::de::Error,
8065                    {
8066                        match value {
8067                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8068                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8069                            "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
8070                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8071                            "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
8072                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8073                        }
8074                    }
8075                }
8076                deserializer.deserialize_identifier(GeneratedVisitor)
8077            }
8078        }
8079        struct GeneratedVisitor;
8080        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8081            type Value = ProjectNode;
8082
8083            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8084                formatter.write_str("struct stream_plan.ProjectNode")
8085            }
8086
8087            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
8088                where
8089                    V: serde::de::MapAccess<'de>,
8090            {
8091                let mut select_list__ = None;
8092                let mut watermark_input_cols__ = None;
8093                let mut watermark_output_cols__ = None;
8094                let mut nondecreasing_exprs__ = None;
8095                let mut noop_update_hint__ = None;
8096                while let Some(k) = map_.next_key()? {
8097                    match k {
8098                        GeneratedField::SelectList => {
8099                            if select_list__.is_some() {
8100                                return Err(serde::de::Error::duplicate_field("selectList"));
8101                            }
8102                            select_list__ = Some(map_.next_value()?);
8103                        }
8104                        GeneratedField::WatermarkInputCols => {
8105                            if watermark_input_cols__.is_some() {
8106                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8107                            }
8108                            watermark_input_cols__ = 
8109                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8110                                    .into_iter().map(|x| x.0).collect())
8111                            ;
8112                        }
8113                        GeneratedField::WatermarkOutputCols => {
8114                            if watermark_output_cols__.is_some() {
8115                                return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
8116                            }
8117                            watermark_output_cols__ = 
8118                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8119                                    .into_iter().map(|x| x.0).collect())
8120                            ;
8121                        }
8122                        GeneratedField::NondecreasingExprs => {
8123                            if nondecreasing_exprs__.is_some() {
8124                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8125                            }
8126                            nondecreasing_exprs__ = 
8127                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8128                                    .into_iter().map(|x| x.0).collect())
8129                            ;
8130                        }
8131                        GeneratedField::NoopUpdateHint => {
8132                            if noop_update_hint__.is_some() {
8133                                return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8134                            }
8135                            noop_update_hint__ = Some(map_.next_value()?);
8136                        }
8137                    }
8138                }
8139                Ok(ProjectNode {
8140                    select_list: select_list__.unwrap_or_default(),
8141                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8142                    watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8143                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8144                    noop_update_hint: noop_update_hint__.unwrap_or_default(),
8145                })
8146            }
8147        }
8148        deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8149    }
8150}
8151impl serde::Serialize for ProjectSetNode {
8152    #[allow(deprecated)]
8153    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8154    where
8155        S: serde::Serializer,
8156    {
8157        use serde::ser::SerializeStruct;
8158        let mut len = 0;
8159        if !self.select_list.is_empty() {
8160            len += 1;
8161        }
8162        if !self.watermark_input_cols.is_empty() {
8163            len += 1;
8164        }
8165        if !self.watermark_expr_indices.is_empty() {
8166            len += 1;
8167        }
8168        if !self.nondecreasing_exprs.is_empty() {
8169            len += 1;
8170        }
8171        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8172        if !self.select_list.is_empty() {
8173            struct_ser.serialize_field("selectList", &self.select_list)?;
8174        }
8175        if !self.watermark_input_cols.is_empty() {
8176            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8177        }
8178        if !self.watermark_expr_indices.is_empty() {
8179            struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8180        }
8181        if !self.nondecreasing_exprs.is_empty() {
8182            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8183        }
8184        struct_ser.end()
8185    }
8186}
8187impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8188    #[allow(deprecated)]
8189    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8190    where
8191        D: serde::Deserializer<'de>,
8192    {
8193        const FIELDS: &[&str] = &[
8194            "select_list",
8195            "selectList",
8196            "watermark_input_cols",
8197            "watermarkInputCols",
8198            "watermark_expr_indices",
8199            "watermarkExprIndices",
8200            "nondecreasing_exprs",
8201            "nondecreasingExprs",
8202        ];
8203
8204        #[allow(clippy::enum_variant_names)]
8205        enum GeneratedField {
8206            SelectList,
8207            WatermarkInputCols,
8208            WatermarkExprIndices,
8209            NondecreasingExprs,
8210        }
8211        impl<'de> serde::Deserialize<'de> for GeneratedField {
8212            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8213            where
8214                D: serde::Deserializer<'de>,
8215            {
8216                struct GeneratedVisitor;
8217
8218                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8219                    type Value = GeneratedField;
8220
8221                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8222                        write!(formatter, "expected one of: {:?}", &FIELDS)
8223                    }
8224
8225                    #[allow(unused_variables)]
8226                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8227                    where
8228                        E: serde::de::Error,
8229                    {
8230                        match value {
8231                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8232                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8233                            "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8234                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8235                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8236                        }
8237                    }
8238                }
8239                deserializer.deserialize_identifier(GeneratedVisitor)
8240            }
8241        }
8242        struct GeneratedVisitor;
8243        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8244            type Value = ProjectSetNode;
8245
8246            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8247                formatter.write_str("struct stream_plan.ProjectSetNode")
8248            }
8249
8250            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8251                where
8252                    V: serde::de::MapAccess<'de>,
8253            {
8254                let mut select_list__ = None;
8255                let mut watermark_input_cols__ = None;
8256                let mut watermark_expr_indices__ = None;
8257                let mut nondecreasing_exprs__ = None;
8258                while let Some(k) = map_.next_key()? {
8259                    match k {
8260                        GeneratedField::SelectList => {
8261                            if select_list__.is_some() {
8262                                return Err(serde::de::Error::duplicate_field("selectList"));
8263                            }
8264                            select_list__ = Some(map_.next_value()?);
8265                        }
8266                        GeneratedField::WatermarkInputCols => {
8267                            if watermark_input_cols__.is_some() {
8268                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8269                            }
8270                            watermark_input_cols__ = 
8271                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8272                                    .into_iter().map(|x| x.0).collect())
8273                            ;
8274                        }
8275                        GeneratedField::WatermarkExprIndices => {
8276                            if watermark_expr_indices__.is_some() {
8277                                return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8278                            }
8279                            watermark_expr_indices__ = 
8280                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8281                                    .into_iter().map(|x| x.0).collect())
8282                            ;
8283                        }
8284                        GeneratedField::NondecreasingExprs => {
8285                            if nondecreasing_exprs__.is_some() {
8286                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8287                            }
8288                            nondecreasing_exprs__ = 
8289                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8290                                    .into_iter().map(|x| x.0).collect())
8291                            ;
8292                        }
8293                    }
8294                }
8295                Ok(ProjectSetNode {
8296                    select_list: select_list__.unwrap_or_default(),
8297                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8298                    watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8299                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8300                })
8301            }
8302        }
8303        deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8304    }
8305}
8306impl serde::Serialize for RefreshStartMutation {
8307    #[allow(deprecated)]
8308    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8309    where
8310        S: serde::Serializer,
8311    {
8312        use serde::ser::SerializeStruct;
8313        let mut len = 0;
8314        if self.table_id != 0 {
8315            len += 1;
8316        }
8317        if self.associated_source_id != 0 {
8318            len += 1;
8319        }
8320        let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8321        if self.table_id != 0 {
8322            struct_ser.serialize_field("tableId", &self.table_id)?;
8323        }
8324        if self.associated_source_id != 0 {
8325            struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8326        }
8327        struct_ser.end()
8328    }
8329}
8330impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8331    #[allow(deprecated)]
8332    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8333    where
8334        D: serde::Deserializer<'de>,
8335    {
8336        const FIELDS: &[&str] = &[
8337            "table_id",
8338            "tableId",
8339            "associated_source_id",
8340            "associatedSourceId",
8341        ];
8342
8343        #[allow(clippy::enum_variant_names)]
8344        enum GeneratedField {
8345            TableId,
8346            AssociatedSourceId,
8347        }
8348        impl<'de> serde::Deserialize<'de> for GeneratedField {
8349            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8350            where
8351                D: serde::Deserializer<'de>,
8352            {
8353                struct GeneratedVisitor;
8354
8355                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8356                    type Value = GeneratedField;
8357
8358                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8359                        write!(formatter, "expected one of: {:?}", &FIELDS)
8360                    }
8361
8362                    #[allow(unused_variables)]
8363                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8364                    where
8365                        E: serde::de::Error,
8366                    {
8367                        match value {
8368                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
8369                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8370                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8371                        }
8372                    }
8373                }
8374                deserializer.deserialize_identifier(GeneratedVisitor)
8375            }
8376        }
8377        struct GeneratedVisitor;
8378        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8379            type Value = RefreshStartMutation;
8380
8381            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8382                formatter.write_str("struct stream_plan.RefreshStartMutation")
8383            }
8384
8385            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8386                where
8387                    V: serde::de::MapAccess<'de>,
8388            {
8389                let mut table_id__ = None;
8390                let mut associated_source_id__ = None;
8391                while let Some(k) = map_.next_key()? {
8392                    match k {
8393                        GeneratedField::TableId => {
8394                            if table_id__.is_some() {
8395                                return Err(serde::de::Error::duplicate_field("tableId"));
8396                            }
8397                            table_id__ = 
8398                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8399                            ;
8400                        }
8401                        GeneratedField::AssociatedSourceId => {
8402                            if associated_source_id__.is_some() {
8403                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8404                            }
8405                            associated_source_id__ = 
8406                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8407                            ;
8408                        }
8409                    }
8410                }
8411                Ok(RefreshStartMutation {
8412                    table_id: table_id__.unwrap_or_default(),
8413                    associated_source_id: associated_source_id__.unwrap_or_default(),
8414                })
8415            }
8416        }
8417        deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8418    }
8419}
8420impl serde::Serialize for ResumeMutation {
8421    #[allow(deprecated)]
8422    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8423    where
8424        S: serde::Serializer,
8425    {
8426        use serde::ser::SerializeStruct;
8427        let len = 0;
8428        let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8429        struct_ser.end()
8430    }
8431}
8432impl<'de> serde::Deserialize<'de> for ResumeMutation {
8433    #[allow(deprecated)]
8434    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8435    where
8436        D: serde::Deserializer<'de>,
8437    {
8438        const FIELDS: &[&str] = &[
8439        ];
8440
8441        #[allow(clippy::enum_variant_names)]
8442        enum GeneratedField {
8443        }
8444        impl<'de> serde::Deserialize<'de> for GeneratedField {
8445            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8446            where
8447                D: serde::Deserializer<'de>,
8448            {
8449                struct GeneratedVisitor;
8450
8451                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8452                    type Value = GeneratedField;
8453
8454                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8455                        write!(formatter, "expected one of: {:?}", &FIELDS)
8456                    }
8457
8458                    #[allow(unused_variables)]
8459                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8460                    where
8461                        E: serde::de::Error,
8462                    {
8463                            Err(serde::de::Error::unknown_field(value, FIELDS))
8464                    }
8465                }
8466                deserializer.deserialize_identifier(GeneratedVisitor)
8467            }
8468        }
8469        struct GeneratedVisitor;
8470        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8471            type Value = ResumeMutation;
8472
8473            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8474                formatter.write_str("struct stream_plan.ResumeMutation")
8475            }
8476
8477            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8478                where
8479                    V: serde::de::MapAccess<'de>,
8480            {
8481                while map_.next_key::<GeneratedField>()?.is_some() {
8482                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8483                }
8484                Ok(ResumeMutation {
8485                })
8486            }
8487        }
8488        deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8489    }
8490}
8491impl serde::Serialize for RowIdGenNode {
8492    #[allow(deprecated)]
8493    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8494    where
8495        S: serde::Serializer,
8496    {
8497        use serde::ser::SerializeStruct;
8498        let mut len = 0;
8499        if self.row_id_index != 0 {
8500            len += 1;
8501        }
8502        let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8503        if self.row_id_index != 0 {
8504            #[allow(clippy::needless_borrow)]
8505            #[allow(clippy::needless_borrows_for_generic_args)]
8506            struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8507        }
8508        struct_ser.end()
8509    }
8510}
8511impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8512    #[allow(deprecated)]
8513    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8514    where
8515        D: serde::Deserializer<'de>,
8516    {
8517        const FIELDS: &[&str] = &[
8518            "row_id_index",
8519            "rowIdIndex",
8520        ];
8521
8522        #[allow(clippy::enum_variant_names)]
8523        enum GeneratedField {
8524            RowIdIndex,
8525        }
8526        impl<'de> serde::Deserialize<'de> for GeneratedField {
8527            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8528            where
8529                D: serde::Deserializer<'de>,
8530            {
8531                struct GeneratedVisitor;
8532
8533                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8534                    type Value = GeneratedField;
8535
8536                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8537                        write!(formatter, "expected one of: {:?}", &FIELDS)
8538                    }
8539
8540                    #[allow(unused_variables)]
8541                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8542                    where
8543                        E: serde::de::Error,
8544                    {
8545                        match value {
8546                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8547                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8548                        }
8549                    }
8550                }
8551                deserializer.deserialize_identifier(GeneratedVisitor)
8552            }
8553        }
8554        struct GeneratedVisitor;
8555        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8556            type Value = RowIdGenNode;
8557
8558            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8559                formatter.write_str("struct stream_plan.RowIdGenNode")
8560            }
8561
8562            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8563                where
8564                    V: serde::de::MapAccess<'de>,
8565            {
8566                let mut row_id_index__ = None;
8567                while let Some(k) = map_.next_key()? {
8568                    match k {
8569                        GeneratedField::RowIdIndex => {
8570                            if row_id_index__.is_some() {
8571                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8572                            }
8573                            row_id_index__ = 
8574                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8575                            ;
8576                        }
8577                    }
8578                }
8579                Ok(RowIdGenNode {
8580                    row_id_index: row_id_index__.unwrap_or_default(),
8581                })
8582            }
8583        }
8584        deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8585    }
8586}
8587impl serde::Serialize for RowMergeNode {
8588    #[allow(deprecated)]
8589    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8590    where
8591        S: serde::Serializer,
8592    {
8593        use serde::ser::SerializeStruct;
8594        let mut len = 0;
8595        if self.lhs_mapping.is_some() {
8596            len += 1;
8597        }
8598        if self.rhs_mapping.is_some() {
8599            len += 1;
8600        }
8601        let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8602        if let Some(v) = self.lhs_mapping.as_ref() {
8603            struct_ser.serialize_field("lhsMapping", v)?;
8604        }
8605        if let Some(v) = self.rhs_mapping.as_ref() {
8606            struct_ser.serialize_field("rhsMapping", v)?;
8607        }
8608        struct_ser.end()
8609    }
8610}
8611impl<'de> serde::Deserialize<'de> for RowMergeNode {
8612    #[allow(deprecated)]
8613    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8614    where
8615        D: serde::Deserializer<'de>,
8616    {
8617        const FIELDS: &[&str] = &[
8618            "lhs_mapping",
8619            "lhsMapping",
8620            "rhs_mapping",
8621            "rhsMapping",
8622        ];
8623
8624        #[allow(clippy::enum_variant_names)]
8625        enum GeneratedField {
8626            LhsMapping,
8627            RhsMapping,
8628        }
8629        impl<'de> serde::Deserialize<'de> for GeneratedField {
8630            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8631            where
8632                D: serde::Deserializer<'de>,
8633            {
8634                struct GeneratedVisitor;
8635
8636                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8637                    type Value = GeneratedField;
8638
8639                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8640                        write!(formatter, "expected one of: {:?}", &FIELDS)
8641                    }
8642
8643                    #[allow(unused_variables)]
8644                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8645                    where
8646                        E: serde::de::Error,
8647                    {
8648                        match value {
8649                            "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8650                            "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8651                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8652                        }
8653                    }
8654                }
8655                deserializer.deserialize_identifier(GeneratedVisitor)
8656            }
8657        }
8658        struct GeneratedVisitor;
8659        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8660            type Value = RowMergeNode;
8661
8662            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8663                formatter.write_str("struct stream_plan.RowMergeNode")
8664            }
8665
8666            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8667                where
8668                    V: serde::de::MapAccess<'de>,
8669            {
8670                let mut lhs_mapping__ = None;
8671                let mut rhs_mapping__ = None;
8672                while let Some(k) = map_.next_key()? {
8673                    match k {
8674                        GeneratedField::LhsMapping => {
8675                            if lhs_mapping__.is_some() {
8676                                return Err(serde::de::Error::duplicate_field("lhsMapping"));
8677                            }
8678                            lhs_mapping__ = map_.next_value()?;
8679                        }
8680                        GeneratedField::RhsMapping => {
8681                            if rhs_mapping__.is_some() {
8682                                return Err(serde::de::Error::duplicate_field("rhsMapping"));
8683                            }
8684                            rhs_mapping__ = map_.next_value()?;
8685                        }
8686                    }
8687                }
8688                Ok(RowMergeNode {
8689                    lhs_mapping: lhs_mapping__,
8690                    rhs_mapping: rhs_mapping__,
8691                })
8692            }
8693        }
8694        deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8695    }
8696}
8697impl serde::Serialize for SimpleAggNode {
8698    #[allow(deprecated)]
8699    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8700    where
8701        S: serde::Serializer,
8702    {
8703        use serde::ser::SerializeStruct;
8704        let mut len = 0;
8705        if !self.agg_calls.is_empty() {
8706            len += 1;
8707        }
8708        if !self.agg_call_states.is_empty() {
8709            len += 1;
8710        }
8711        if self.intermediate_state_table.is_some() {
8712            len += 1;
8713        }
8714        if self.is_append_only {
8715            len += 1;
8716        }
8717        if !self.distinct_dedup_tables.is_empty() {
8718            len += 1;
8719        }
8720        if self.row_count_index != 0 {
8721            len += 1;
8722        }
8723        if self.version != 0 {
8724            len += 1;
8725        }
8726        if self.must_output_per_barrier {
8727            len += 1;
8728        }
8729        let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8730        if !self.agg_calls.is_empty() {
8731            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8732        }
8733        if !self.agg_call_states.is_empty() {
8734            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8735        }
8736        if let Some(v) = self.intermediate_state_table.as_ref() {
8737            struct_ser.serialize_field("intermediateStateTable", v)?;
8738        }
8739        if self.is_append_only {
8740            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8741        }
8742        if !self.distinct_dedup_tables.is_empty() {
8743            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8744        }
8745        if self.row_count_index != 0 {
8746            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8747        }
8748        if self.version != 0 {
8749            let v = AggNodeVersion::try_from(self.version)
8750                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8751            struct_ser.serialize_field("version", &v)?;
8752        }
8753        if self.must_output_per_barrier {
8754            struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8755        }
8756        struct_ser.end()
8757    }
8758}
8759impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8760    #[allow(deprecated)]
8761    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8762    where
8763        D: serde::Deserializer<'de>,
8764    {
8765        const FIELDS: &[&str] = &[
8766            "agg_calls",
8767            "aggCalls",
8768            "agg_call_states",
8769            "aggCallStates",
8770            "intermediate_state_table",
8771            "intermediateStateTable",
8772            "is_append_only",
8773            "isAppendOnly",
8774            "distinct_dedup_tables",
8775            "distinctDedupTables",
8776            "row_count_index",
8777            "rowCountIndex",
8778            "version",
8779            "must_output_per_barrier",
8780            "mustOutputPerBarrier",
8781        ];
8782
8783        #[allow(clippy::enum_variant_names)]
8784        enum GeneratedField {
8785            AggCalls,
8786            AggCallStates,
8787            IntermediateStateTable,
8788            IsAppendOnly,
8789            DistinctDedupTables,
8790            RowCountIndex,
8791            Version,
8792            MustOutputPerBarrier,
8793        }
8794        impl<'de> serde::Deserialize<'de> for GeneratedField {
8795            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8796            where
8797                D: serde::Deserializer<'de>,
8798            {
8799                struct GeneratedVisitor;
8800
8801                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8802                    type Value = GeneratedField;
8803
8804                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8805                        write!(formatter, "expected one of: {:?}", &FIELDS)
8806                    }
8807
8808                    #[allow(unused_variables)]
8809                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8810                    where
8811                        E: serde::de::Error,
8812                    {
8813                        match value {
8814                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8815                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8816                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8817                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8818                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8819                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8820                            "version" => Ok(GeneratedField::Version),
8821                            "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8822                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8823                        }
8824                    }
8825                }
8826                deserializer.deserialize_identifier(GeneratedVisitor)
8827            }
8828        }
8829        struct GeneratedVisitor;
8830        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8831            type Value = SimpleAggNode;
8832
8833            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8834                formatter.write_str("struct stream_plan.SimpleAggNode")
8835            }
8836
8837            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8838                where
8839                    V: serde::de::MapAccess<'de>,
8840            {
8841                let mut agg_calls__ = None;
8842                let mut agg_call_states__ = None;
8843                let mut intermediate_state_table__ = None;
8844                let mut is_append_only__ = None;
8845                let mut distinct_dedup_tables__ = None;
8846                let mut row_count_index__ = None;
8847                let mut version__ = None;
8848                let mut must_output_per_barrier__ = None;
8849                while let Some(k) = map_.next_key()? {
8850                    match k {
8851                        GeneratedField::AggCalls => {
8852                            if agg_calls__.is_some() {
8853                                return Err(serde::de::Error::duplicate_field("aggCalls"));
8854                            }
8855                            agg_calls__ = Some(map_.next_value()?);
8856                        }
8857                        GeneratedField::AggCallStates => {
8858                            if agg_call_states__.is_some() {
8859                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
8860                            }
8861                            agg_call_states__ = Some(map_.next_value()?);
8862                        }
8863                        GeneratedField::IntermediateStateTable => {
8864                            if intermediate_state_table__.is_some() {
8865                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8866                            }
8867                            intermediate_state_table__ = map_.next_value()?;
8868                        }
8869                        GeneratedField::IsAppendOnly => {
8870                            if is_append_only__.is_some() {
8871                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8872                            }
8873                            is_append_only__ = Some(map_.next_value()?);
8874                        }
8875                        GeneratedField::DistinctDedupTables => {
8876                            if distinct_dedup_tables__.is_some() {
8877                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8878                            }
8879                            distinct_dedup_tables__ = Some(
8880                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8881                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8882                            );
8883                        }
8884                        GeneratedField::RowCountIndex => {
8885                            if row_count_index__.is_some() {
8886                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8887                            }
8888                            row_count_index__ = 
8889                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8890                            ;
8891                        }
8892                        GeneratedField::Version => {
8893                            if version__.is_some() {
8894                                return Err(serde::de::Error::duplicate_field("version"));
8895                            }
8896                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8897                        }
8898                        GeneratedField::MustOutputPerBarrier => {
8899                            if must_output_per_barrier__.is_some() {
8900                                return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8901                            }
8902                            must_output_per_barrier__ = Some(map_.next_value()?);
8903                        }
8904                    }
8905                }
8906                Ok(SimpleAggNode {
8907                    agg_calls: agg_calls__.unwrap_or_default(),
8908                    agg_call_states: agg_call_states__.unwrap_or_default(),
8909                    intermediate_state_table: intermediate_state_table__,
8910                    is_append_only: is_append_only__.unwrap_or_default(),
8911                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8912                    row_count_index: row_count_index__.unwrap_or_default(),
8913                    version: version__.unwrap_or_default(),
8914                    must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8915                })
8916            }
8917        }
8918        deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8919    }
8920}
8921impl serde::Serialize for SinkAddColumns {
8922    #[allow(deprecated)]
8923    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8924    where
8925        S: serde::Serializer,
8926    {
8927        use serde::ser::SerializeStruct;
8928        let mut len = 0;
8929        if !self.fields.is_empty() {
8930            len += 1;
8931        }
8932        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
8933        if !self.fields.is_empty() {
8934            struct_ser.serialize_field("fields", &self.fields)?;
8935        }
8936        struct_ser.end()
8937    }
8938}
8939impl<'de> serde::Deserialize<'de> for SinkAddColumns {
8940    #[allow(deprecated)]
8941    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8942    where
8943        D: serde::Deserializer<'de>,
8944    {
8945        const FIELDS: &[&str] = &[
8946            "fields",
8947        ];
8948
8949        #[allow(clippy::enum_variant_names)]
8950        enum GeneratedField {
8951            Fields,
8952        }
8953        impl<'de> serde::Deserialize<'de> for GeneratedField {
8954            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8955            where
8956                D: serde::Deserializer<'de>,
8957            {
8958                struct GeneratedVisitor;
8959
8960                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8961                    type Value = GeneratedField;
8962
8963                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8964                        write!(formatter, "expected one of: {:?}", &FIELDS)
8965                    }
8966
8967                    #[allow(unused_variables)]
8968                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8969                    where
8970                        E: serde::de::Error,
8971                    {
8972                        match value {
8973                            "fields" => Ok(GeneratedField::Fields),
8974                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8975                        }
8976                    }
8977                }
8978                deserializer.deserialize_identifier(GeneratedVisitor)
8979            }
8980        }
8981        struct GeneratedVisitor;
8982        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8983            type Value = SinkAddColumns;
8984
8985            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8986                formatter.write_str("struct stream_plan.SinkAddColumns")
8987            }
8988
8989            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
8990                where
8991                    V: serde::de::MapAccess<'de>,
8992            {
8993                let mut fields__ = None;
8994                while let Some(k) = map_.next_key()? {
8995                    match k {
8996                        GeneratedField::Fields => {
8997                            if fields__.is_some() {
8998                                return Err(serde::de::Error::duplicate_field("fields"));
8999                            }
9000                            fields__ = Some(map_.next_value()?);
9001                        }
9002                    }
9003                }
9004                Ok(SinkAddColumns {
9005                    fields: fields__.unwrap_or_default(),
9006                })
9007            }
9008        }
9009        deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
9010    }
9011}
9012impl serde::Serialize for SinkDesc {
9013    #[allow(deprecated)]
9014    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9015    where
9016        S: serde::Serializer,
9017    {
9018        use serde::ser::SerializeStruct;
9019        let mut len = 0;
9020        if self.id != 0 {
9021            len += 1;
9022        }
9023        if !self.name.is_empty() {
9024            len += 1;
9025        }
9026        if !self.definition.is_empty() {
9027            len += 1;
9028        }
9029        if !self.plan_pk.is_empty() {
9030            len += 1;
9031        }
9032        if !self.downstream_pk.is_empty() {
9033            len += 1;
9034        }
9035        if !self.distribution_key.is_empty() {
9036            len += 1;
9037        }
9038        if !self.properties.is_empty() {
9039            len += 1;
9040        }
9041        if self.sink_type != 0 {
9042            len += 1;
9043        }
9044        if !self.column_catalogs.is_empty() {
9045            len += 1;
9046        }
9047        if !self.db_name.is_empty() {
9048            len += 1;
9049        }
9050        if !self.sink_from_name.is_empty() {
9051            len += 1;
9052        }
9053        if self.format_desc.is_some() {
9054            len += 1;
9055        }
9056        if self.target_table.is_some() {
9057            len += 1;
9058        }
9059        if self.extra_partition_col_idx.is_some() {
9060            len += 1;
9061        }
9062        if !self.secret_refs.is_empty() {
9063            len += 1;
9064        }
9065        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
9066        if self.id != 0 {
9067            struct_ser.serialize_field("id", &self.id)?;
9068        }
9069        if !self.name.is_empty() {
9070            struct_ser.serialize_field("name", &self.name)?;
9071        }
9072        if !self.definition.is_empty() {
9073            struct_ser.serialize_field("definition", &self.definition)?;
9074        }
9075        if !self.plan_pk.is_empty() {
9076            struct_ser.serialize_field("planPk", &self.plan_pk)?;
9077        }
9078        if !self.downstream_pk.is_empty() {
9079            struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
9080        }
9081        if !self.distribution_key.is_empty() {
9082            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
9083        }
9084        if !self.properties.is_empty() {
9085            struct_ser.serialize_field("properties", &self.properties)?;
9086        }
9087        if self.sink_type != 0 {
9088            let v = super::catalog::SinkType::try_from(self.sink_type)
9089                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
9090            struct_ser.serialize_field("sinkType", &v)?;
9091        }
9092        if !self.column_catalogs.is_empty() {
9093            struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
9094        }
9095        if !self.db_name.is_empty() {
9096            struct_ser.serialize_field("dbName", &self.db_name)?;
9097        }
9098        if !self.sink_from_name.is_empty() {
9099            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
9100        }
9101        if let Some(v) = self.format_desc.as_ref() {
9102            struct_ser.serialize_field("formatDesc", v)?;
9103        }
9104        if let Some(v) = self.target_table.as_ref() {
9105            struct_ser.serialize_field("targetTable", v)?;
9106        }
9107        if let Some(v) = self.extra_partition_col_idx.as_ref() {
9108            #[allow(clippy::needless_borrow)]
9109            #[allow(clippy::needless_borrows_for_generic_args)]
9110            struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
9111        }
9112        if !self.secret_refs.is_empty() {
9113            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9114        }
9115        struct_ser.end()
9116    }
9117}
9118impl<'de> serde::Deserialize<'de> for SinkDesc {
9119    #[allow(deprecated)]
9120    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9121    where
9122        D: serde::Deserializer<'de>,
9123    {
9124        const FIELDS: &[&str] = &[
9125            "id",
9126            "name",
9127            "definition",
9128            "plan_pk",
9129            "planPk",
9130            "downstream_pk",
9131            "downstreamPk",
9132            "distribution_key",
9133            "distributionKey",
9134            "properties",
9135            "sink_type",
9136            "sinkType",
9137            "column_catalogs",
9138            "columnCatalogs",
9139            "db_name",
9140            "dbName",
9141            "sink_from_name",
9142            "sinkFromName",
9143            "format_desc",
9144            "formatDesc",
9145            "target_table",
9146            "targetTable",
9147            "extra_partition_col_idx",
9148            "extraPartitionColIdx",
9149            "secret_refs",
9150            "secretRefs",
9151        ];
9152
9153        #[allow(clippy::enum_variant_names)]
9154        enum GeneratedField {
9155            Id,
9156            Name,
9157            Definition,
9158            PlanPk,
9159            DownstreamPk,
9160            DistributionKey,
9161            Properties,
9162            SinkType,
9163            ColumnCatalogs,
9164            DbName,
9165            SinkFromName,
9166            FormatDesc,
9167            TargetTable,
9168            ExtraPartitionColIdx,
9169            SecretRefs,
9170        }
9171        impl<'de> serde::Deserialize<'de> for GeneratedField {
9172            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9173            where
9174                D: serde::Deserializer<'de>,
9175            {
9176                struct GeneratedVisitor;
9177
9178                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9179                    type Value = GeneratedField;
9180
9181                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9182                        write!(formatter, "expected one of: {:?}", &FIELDS)
9183                    }
9184
9185                    #[allow(unused_variables)]
9186                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9187                    where
9188                        E: serde::de::Error,
9189                    {
9190                        match value {
9191                            "id" => Ok(GeneratedField::Id),
9192                            "name" => Ok(GeneratedField::Name),
9193                            "definition" => Ok(GeneratedField::Definition),
9194                            "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9195                            "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9196                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9197                            "properties" => Ok(GeneratedField::Properties),
9198                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9199                            "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9200                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
9201                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9202                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9203                            "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9204                            "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9205                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9206                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9207                        }
9208                    }
9209                }
9210                deserializer.deserialize_identifier(GeneratedVisitor)
9211            }
9212        }
9213        struct GeneratedVisitor;
9214        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9215            type Value = SinkDesc;
9216
9217            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9218                formatter.write_str("struct stream_plan.SinkDesc")
9219            }
9220
9221            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9222                where
9223                    V: serde::de::MapAccess<'de>,
9224            {
9225                let mut id__ = None;
9226                let mut name__ = None;
9227                let mut definition__ = None;
9228                let mut plan_pk__ = None;
9229                let mut downstream_pk__ = None;
9230                let mut distribution_key__ = None;
9231                let mut properties__ = None;
9232                let mut sink_type__ = None;
9233                let mut column_catalogs__ = None;
9234                let mut db_name__ = None;
9235                let mut sink_from_name__ = None;
9236                let mut format_desc__ = None;
9237                let mut target_table__ = None;
9238                let mut extra_partition_col_idx__ = None;
9239                let mut secret_refs__ = None;
9240                while let Some(k) = map_.next_key()? {
9241                    match k {
9242                        GeneratedField::Id => {
9243                            if id__.is_some() {
9244                                return Err(serde::de::Error::duplicate_field("id"));
9245                            }
9246                            id__ = 
9247                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9248                            ;
9249                        }
9250                        GeneratedField::Name => {
9251                            if name__.is_some() {
9252                                return Err(serde::de::Error::duplicate_field("name"));
9253                            }
9254                            name__ = Some(map_.next_value()?);
9255                        }
9256                        GeneratedField::Definition => {
9257                            if definition__.is_some() {
9258                                return Err(serde::de::Error::duplicate_field("definition"));
9259                            }
9260                            definition__ = Some(map_.next_value()?);
9261                        }
9262                        GeneratedField::PlanPk => {
9263                            if plan_pk__.is_some() {
9264                                return Err(serde::de::Error::duplicate_field("planPk"));
9265                            }
9266                            plan_pk__ = Some(map_.next_value()?);
9267                        }
9268                        GeneratedField::DownstreamPk => {
9269                            if downstream_pk__.is_some() {
9270                                return Err(serde::de::Error::duplicate_field("downstreamPk"));
9271                            }
9272                            downstream_pk__ = 
9273                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9274                                    .into_iter().map(|x| x.0).collect())
9275                            ;
9276                        }
9277                        GeneratedField::DistributionKey => {
9278                            if distribution_key__.is_some() {
9279                                return Err(serde::de::Error::duplicate_field("distributionKey"));
9280                            }
9281                            distribution_key__ = 
9282                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9283                                    .into_iter().map(|x| x.0).collect())
9284                            ;
9285                        }
9286                        GeneratedField::Properties => {
9287                            if properties__.is_some() {
9288                                return Err(serde::de::Error::duplicate_field("properties"));
9289                            }
9290                            properties__ = Some(
9291                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9292                            );
9293                        }
9294                        GeneratedField::SinkType => {
9295                            if sink_type__.is_some() {
9296                                return Err(serde::de::Error::duplicate_field("sinkType"));
9297                            }
9298                            sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9299                        }
9300                        GeneratedField::ColumnCatalogs => {
9301                            if column_catalogs__.is_some() {
9302                                return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9303                            }
9304                            column_catalogs__ = Some(map_.next_value()?);
9305                        }
9306                        GeneratedField::DbName => {
9307                            if db_name__.is_some() {
9308                                return Err(serde::de::Error::duplicate_field("dbName"));
9309                            }
9310                            db_name__ = Some(map_.next_value()?);
9311                        }
9312                        GeneratedField::SinkFromName => {
9313                            if sink_from_name__.is_some() {
9314                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
9315                            }
9316                            sink_from_name__ = Some(map_.next_value()?);
9317                        }
9318                        GeneratedField::FormatDesc => {
9319                            if format_desc__.is_some() {
9320                                return Err(serde::de::Error::duplicate_field("formatDesc"));
9321                            }
9322                            format_desc__ = map_.next_value()?;
9323                        }
9324                        GeneratedField::TargetTable => {
9325                            if target_table__.is_some() {
9326                                return Err(serde::de::Error::duplicate_field("targetTable"));
9327                            }
9328                            target_table__ = 
9329                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9330                            ;
9331                        }
9332                        GeneratedField::ExtraPartitionColIdx => {
9333                            if extra_partition_col_idx__.is_some() {
9334                                return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9335                            }
9336                            extra_partition_col_idx__ = 
9337                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9338                            ;
9339                        }
9340                        GeneratedField::SecretRefs => {
9341                            if secret_refs__.is_some() {
9342                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9343                            }
9344                            secret_refs__ = Some(
9345                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9346                            );
9347                        }
9348                    }
9349                }
9350                Ok(SinkDesc {
9351                    id: id__.unwrap_or_default(),
9352                    name: name__.unwrap_or_default(),
9353                    definition: definition__.unwrap_or_default(),
9354                    plan_pk: plan_pk__.unwrap_or_default(),
9355                    downstream_pk: downstream_pk__.unwrap_or_default(),
9356                    distribution_key: distribution_key__.unwrap_or_default(),
9357                    properties: properties__.unwrap_or_default(),
9358                    sink_type: sink_type__.unwrap_or_default(),
9359                    column_catalogs: column_catalogs__.unwrap_or_default(),
9360                    db_name: db_name__.unwrap_or_default(),
9361                    sink_from_name: sink_from_name__.unwrap_or_default(),
9362                    format_desc: format_desc__,
9363                    target_table: target_table__,
9364                    extra_partition_col_idx: extra_partition_col_idx__,
9365                    secret_refs: secret_refs__.unwrap_or_default(),
9366                })
9367            }
9368        }
9369        deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9370    }
9371}
9372impl serde::Serialize for SinkLogStoreType {
9373    #[allow(deprecated)]
9374    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9375    where
9376        S: serde::Serializer,
9377    {
9378        let variant = match self {
9379            Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9380            Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9381            Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9382        };
9383        serializer.serialize_str(variant)
9384    }
9385}
9386impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9387    #[allow(deprecated)]
9388    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9389    where
9390        D: serde::Deserializer<'de>,
9391    {
9392        const FIELDS: &[&str] = &[
9393            "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9394            "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9395            "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9396        ];
9397
9398        struct GeneratedVisitor;
9399
9400        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9401            type Value = SinkLogStoreType;
9402
9403            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9404                write!(formatter, "expected one of: {:?}", &FIELDS)
9405            }
9406
9407            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9408            where
9409                E: serde::de::Error,
9410            {
9411                i32::try_from(v)
9412                    .ok()
9413                    .and_then(|x| x.try_into().ok())
9414                    .ok_or_else(|| {
9415                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9416                    })
9417            }
9418
9419            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9420            where
9421                E: serde::de::Error,
9422            {
9423                i32::try_from(v)
9424                    .ok()
9425                    .and_then(|x| x.try_into().ok())
9426                    .ok_or_else(|| {
9427                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9428                    })
9429            }
9430
9431            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9432            where
9433                E: serde::de::Error,
9434            {
9435                match value {
9436                    "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9437                    "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9438                    "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9439                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9440                }
9441            }
9442        }
9443        deserializer.deserialize_any(GeneratedVisitor)
9444    }
9445}
9446impl serde::Serialize for SinkNode {
9447    #[allow(deprecated)]
9448    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9449    where
9450        S: serde::Serializer,
9451    {
9452        use serde::ser::SerializeStruct;
9453        let mut len = 0;
9454        if self.sink_desc.is_some() {
9455            len += 1;
9456        }
9457        if self.table.is_some() {
9458            len += 1;
9459        }
9460        if self.log_store_type != 0 {
9461            len += 1;
9462        }
9463        if self.rate_limit.is_some() {
9464            len += 1;
9465        }
9466        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9467        if let Some(v) = self.sink_desc.as_ref() {
9468            struct_ser.serialize_field("sinkDesc", v)?;
9469        }
9470        if let Some(v) = self.table.as_ref() {
9471            struct_ser.serialize_field("table", v)?;
9472        }
9473        if self.log_store_type != 0 {
9474            let v = SinkLogStoreType::try_from(self.log_store_type)
9475                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9476            struct_ser.serialize_field("logStoreType", &v)?;
9477        }
9478        if let Some(v) = self.rate_limit.as_ref() {
9479            struct_ser.serialize_field("rateLimit", v)?;
9480        }
9481        struct_ser.end()
9482    }
9483}
9484impl<'de> serde::Deserialize<'de> for SinkNode {
9485    #[allow(deprecated)]
9486    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9487    where
9488        D: serde::Deserializer<'de>,
9489    {
9490        const FIELDS: &[&str] = &[
9491            "sink_desc",
9492            "sinkDesc",
9493            "table",
9494            "log_store_type",
9495            "logStoreType",
9496            "rate_limit",
9497            "rateLimit",
9498        ];
9499
9500        #[allow(clippy::enum_variant_names)]
9501        enum GeneratedField {
9502            SinkDesc,
9503            Table,
9504            LogStoreType,
9505            RateLimit,
9506        }
9507        impl<'de> serde::Deserialize<'de> for GeneratedField {
9508            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9509            where
9510                D: serde::Deserializer<'de>,
9511            {
9512                struct GeneratedVisitor;
9513
9514                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9515                    type Value = GeneratedField;
9516
9517                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9518                        write!(formatter, "expected one of: {:?}", &FIELDS)
9519                    }
9520
9521                    #[allow(unused_variables)]
9522                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9523                    where
9524                        E: serde::de::Error,
9525                    {
9526                        match value {
9527                            "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9528                            "table" => Ok(GeneratedField::Table),
9529                            "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9530                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9531                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9532                        }
9533                    }
9534                }
9535                deserializer.deserialize_identifier(GeneratedVisitor)
9536            }
9537        }
9538        struct GeneratedVisitor;
9539        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9540            type Value = SinkNode;
9541
9542            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9543                formatter.write_str("struct stream_plan.SinkNode")
9544            }
9545
9546            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9547                where
9548                    V: serde::de::MapAccess<'de>,
9549            {
9550                let mut sink_desc__ = None;
9551                let mut table__ = None;
9552                let mut log_store_type__ = None;
9553                let mut rate_limit__ = None;
9554                while let Some(k) = map_.next_key()? {
9555                    match k {
9556                        GeneratedField::SinkDesc => {
9557                            if sink_desc__.is_some() {
9558                                return Err(serde::de::Error::duplicate_field("sinkDesc"));
9559                            }
9560                            sink_desc__ = map_.next_value()?;
9561                        }
9562                        GeneratedField::Table => {
9563                            if table__.is_some() {
9564                                return Err(serde::de::Error::duplicate_field("table"));
9565                            }
9566                            table__ = map_.next_value()?;
9567                        }
9568                        GeneratedField::LogStoreType => {
9569                            if log_store_type__.is_some() {
9570                                return Err(serde::de::Error::duplicate_field("logStoreType"));
9571                            }
9572                            log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
9573                        }
9574                        GeneratedField::RateLimit => {
9575                            if rate_limit__.is_some() {
9576                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9577                            }
9578                            rate_limit__ = 
9579                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9580                            ;
9581                        }
9582                    }
9583                }
9584                Ok(SinkNode {
9585                    sink_desc: sink_desc__,
9586                    table: table__,
9587                    log_store_type: log_store_type__.unwrap_or_default(),
9588                    rate_limit: rate_limit__,
9589                })
9590            }
9591        }
9592        deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
9593    }
9594}
9595impl serde::Serialize for SortNode {
9596    #[allow(deprecated)]
9597    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9598    where
9599        S: serde::Serializer,
9600    {
9601        use serde::ser::SerializeStruct;
9602        let mut len = 0;
9603        if self.state_table.is_some() {
9604            len += 1;
9605        }
9606        if self.sort_column_index != 0 {
9607            len += 1;
9608        }
9609        let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
9610        if let Some(v) = self.state_table.as_ref() {
9611            struct_ser.serialize_field("stateTable", v)?;
9612        }
9613        if self.sort_column_index != 0 {
9614            struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
9615        }
9616        struct_ser.end()
9617    }
9618}
9619impl<'de> serde::Deserialize<'de> for SortNode {
9620    #[allow(deprecated)]
9621    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9622    where
9623        D: serde::Deserializer<'de>,
9624    {
9625        const FIELDS: &[&str] = &[
9626            "state_table",
9627            "stateTable",
9628            "sort_column_index",
9629            "sortColumnIndex",
9630        ];
9631
9632        #[allow(clippy::enum_variant_names)]
9633        enum GeneratedField {
9634            StateTable,
9635            SortColumnIndex,
9636        }
9637        impl<'de> serde::Deserialize<'de> for GeneratedField {
9638            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9639            where
9640                D: serde::Deserializer<'de>,
9641            {
9642                struct GeneratedVisitor;
9643
9644                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9645                    type Value = GeneratedField;
9646
9647                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9648                        write!(formatter, "expected one of: {:?}", &FIELDS)
9649                    }
9650
9651                    #[allow(unused_variables)]
9652                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9653                    where
9654                        E: serde::de::Error,
9655                    {
9656                        match value {
9657                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9658                            "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9659                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9660                        }
9661                    }
9662                }
9663                deserializer.deserialize_identifier(GeneratedVisitor)
9664            }
9665        }
9666        struct GeneratedVisitor;
9667        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9668            type Value = SortNode;
9669
9670            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9671                formatter.write_str("struct stream_plan.SortNode")
9672            }
9673
9674            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9675                where
9676                    V: serde::de::MapAccess<'de>,
9677            {
9678                let mut state_table__ = None;
9679                let mut sort_column_index__ = None;
9680                while let Some(k) = map_.next_key()? {
9681                    match k {
9682                        GeneratedField::StateTable => {
9683                            if state_table__.is_some() {
9684                                return Err(serde::de::Error::duplicate_field("stateTable"));
9685                            }
9686                            state_table__ = map_.next_value()?;
9687                        }
9688                        GeneratedField::SortColumnIndex => {
9689                            if sort_column_index__.is_some() {
9690                                return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9691                            }
9692                            sort_column_index__ = 
9693                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9694                            ;
9695                        }
9696                    }
9697                }
9698                Ok(SortNode {
9699                    state_table: state_table__,
9700                    sort_column_index: sort_column_index__.unwrap_or_default(),
9701                })
9702            }
9703        }
9704        deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9705    }
9706}
9707impl serde::Serialize for SourceBackfillNode {
9708    #[allow(deprecated)]
9709    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9710    where
9711        S: serde::Serializer,
9712    {
9713        use serde::ser::SerializeStruct;
9714        let mut len = 0;
9715        if self.upstream_source_id != 0 {
9716            len += 1;
9717        }
9718        if self.row_id_index.is_some() {
9719            len += 1;
9720        }
9721        if !self.columns.is_empty() {
9722            len += 1;
9723        }
9724        if self.info.is_some() {
9725            len += 1;
9726        }
9727        if !self.source_name.is_empty() {
9728            len += 1;
9729        }
9730        if !self.with_properties.is_empty() {
9731            len += 1;
9732        }
9733        if self.rate_limit.is_some() {
9734            len += 1;
9735        }
9736        if self.state_table.is_some() {
9737            len += 1;
9738        }
9739        if !self.secret_refs.is_empty() {
9740            len += 1;
9741        }
9742        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9743        if self.upstream_source_id != 0 {
9744            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9745        }
9746        if let Some(v) = self.row_id_index.as_ref() {
9747            struct_ser.serialize_field("rowIdIndex", v)?;
9748        }
9749        if !self.columns.is_empty() {
9750            struct_ser.serialize_field("columns", &self.columns)?;
9751        }
9752        if let Some(v) = self.info.as_ref() {
9753            struct_ser.serialize_field("info", v)?;
9754        }
9755        if !self.source_name.is_empty() {
9756            struct_ser.serialize_field("sourceName", &self.source_name)?;
9757        }
9758        if !self.with_properties.is_empty() {
9759            struct_ser.serialize_field("withProperties", &self.with_properties)?;
9760        }
9761        if let Some(v) = self.rate_limit.as_ref() {
9762            struct_ser.serialize_field("rateLimit", v)?;
9763        }
9764        if let Some(v) = self.state_table.as_ref() {
9765            struct_ser.serialize_field("stateTable", v)?;
9766        }
9767        if !self.secret_refs.is_empty() {
9768            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9769        }
9770        struct_ser.end()
9771    }
9772}
9773impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9774    #[allow(deprecated)]
9775    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9776    where
9777        D: serde::Deserializer<'de>,
9778    {
9779        const FIELDS: &[&str] = &[
9780            "upstream_source_id",
9781            "upstreamSourceId",
9782            "row_id_index",
9783            "rowIdIndex",
9784            "columns",
9785            "info",
9786            "source_name",
9787            "sourceName",
9788            "with_properties",
9789            "withProperties",
9790            "rate_limit",
9791            "rateLimit",
9792            "state_table",
9793            "stateTable",
9794            "secret_refs",
9795            "secretRefs",
9796        ];
9797
9798        #[allow(clippy::enum_variant_names)]
9799        enum GeneratedField {
9800            UpstreamSourceId,
9801            RowIdIndex,
9802            Columns,
9803            Info,
9804            SourceName,
9805            WithProperties,
9806            RateLimit,
9807            StateTable,
9808            SecretRefs,
9809        }
9810        impl<'de> serde::Deserialize<'de> for GeneratedField {
9811            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9812            where
9813                D: serde::Deserializer<'de>,
9814            {
9815                struct GeneratedVisitor;
9816
9817                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9818                    type Value = GeneratedField;
9819
9820                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9821                        write!(formatter, "expected one of: {:?}", &FIELDS)
9822                    }
9823
9824                    #[allow(unused_variables)]
9825                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9826                    where
9827                        E: serde::de::Error,
9828                    {
9829                        match value {
9830                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9831                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9832                            "columns" => Ok(GeneratedField::Columns),
9833                            "info" => Ok(GeneratedField::Info),
9834                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9835                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9836                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9837                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9838                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9839                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9840                        }
9841                    }
9842                }
9843                deserializer.deserialize_identifier(GeneratedVisitor)
9844            }
9845        }
9846        struct GeneratedVisitor;
9847        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9848            type Value = SourceBackfillNode;
9849
9850            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9851                formatter.write_str("struct stream_plan.SourceBackfillNode")
9852            }
9853
9854            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9855                where
9856                    V: serde::de::MapAccess<'de>,
9857            {
9858                let mut upstream_source_id__ = None;
9859                let mut row_id_index__ = None;
9860                let mut columns__ = None;
9861                let mut info__ = None;
9862                let mut source_name__ = None;
9863                let mut with_properties__ = None;
9864                let mut rate_limit__ = None;
9865                let mut state_table__ = None;
9866                let mut secret_refs__ = None;
9867                while let Some(k) = map_.next_key()? {
9868                    match k {
9869                        GeneratedField::UpstreamSourceId => {
9870                            if upstream_source_id__.is_some() {
9871                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9872                            }
9873                            upstream_source_id__ = 
9874                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9875                            ;
9876                        }
9877                        GeneratedField::RowIdIndex => {
9878                            if row_id_index__.is_some() {
9879                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9880                            }
9881                            row_id_index__ = 
9882                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9883                            ;
9884                        }
9885                        GeneratedField::Columns => {
9886                            if columns__.is_some() {
9887                                return Err(serde::de::Error::duplicate_field("columns"));
9888                            }
9889                            columns__ = Some(map_.next_value()?);
9890                        }
9891                        GeneratedField::Info => {
9892                            if info__.is_some() {
9893                                return Err(serde::de::Error::duplicate_field("info"));
9894                            }
9895                            info__ = map_.next_value()?;
9896                        }
9897                        GeneratedField::SourceName => {
9898                            if source_name__.is_some() {
9899                                return Err(serde::de::Error::duplicate_field("sourceName"));
9900                            }
9901                            source_name__ = Some(map_.next_value()?);
9902                        }
9903                        GeneratedField::WithProperties => {
9904                            if with_properties__.is_some() {
9905                                return Err(serde::de::Error::duplicate_field("withProperties"));
9906                            }
9907                            with_properties__ = Some(
9908                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9909                            );
9910                        }
9911                        GeneratedField::RateLimit => {
9912                            if rate_limit__.is_some() {
9913                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9914                            }
9915                            rate_limit__ = 
9916                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9917                            ;
9918                        }
9919                        GeneratedField::StateTable => {
9920                            if state_table__.is_some() {
9921                                return Err(serde::de::Error::duplicate_field("stateTable"));
9922                            }
9923                            state_table__ = map_.next_value()?;
9924                        }
9925                        GeneratedField::SecretRefs => {
9926                            if secret_refs__.is_some() {
9927                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9928                            }
9929                            secret_refs__ = Some(
9930                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9931                            );
9932                        }
9933                    }
9934                }
9935                Ok(SourceBackfillNode {
9936                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
9937                    row_id_index: row_id_index__,
9938                    columns: columns__.unwrap_or_default(),
9939                    info: info__,
9940                    source_name: source_name__.unwrap_or_default(),
9941                    with_properties: with_properties__.unwrap_or_default(),
9942                    rate_limit: rate_limit__,
9943                    state_table: state_table__,
9944                    secret_refs: secret_refs__.unwrap_or_default(),
9945                })
9946            }
9947        }
9948        deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9949    }
9950}
9951impl serde::Serialize for SourceChangeSplitMutation {
9952    #[allow(deprecated)]
9953    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9954    where
9955        S: serde::Serializer,
9956    {
9957        use serde::ser::SerializeStruct;
9958        let mut len = 0;
9959        if !self.actor_splits.is_empty() {
9960            len += 1;
9961        }
9962        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9963        if !self.actor_splits.is_empty() {
9964            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9965        }
9966        struct_ser.end()
9967    }
9968}
9969impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9970    #[allow(deprecated)]
9971    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9972    where
9973        D: serde::Deserializer<'de>,
9974    {
9975        const FIELDS: &[&str] = &[
9976            "actor_splits",
9977            "actorSplits",
9978        ];
9979
9980        #[allow(clippy::enum_variant_names)]
9981        enum GeneratedField {
9982            ActorSplits,
9983        }
9984        impl<'de> serde::Deserialize<'de> for GeneratedField {
9985            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9986            where
9987                D: serde::Deserializer<'de>,
9988            {
9989                struct GeneratedVisitor;
9990
9991                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9992                    type Value = GeneratedField;
9993
9994                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9995                        write!(formatter, "expected one of: {:?}", &FIELDS)
9996                    }
9997
9998                    #[allow(unused_variables)]
9999                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10000                    where
10001                        E: serde::de::Error,
10002                    {
10003                        match value {
10004                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
10005                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10006                        }
10007                    }
10008                }
10009                deserializer.deserialize_identifier(GeneratedVisitor)
10010            }
10011        }
10012        struct GeneratedVisitor;
10013        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10014            type Value = SourceChangeSplitMutation;
10015
10016            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10017                formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
10018            }
10019
10020            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
10021                where
10022                    V: serde::de::MapAccess<'de>,
10023            {
10024                let mut actor_splits__ = None;
10025                while let Some(k) = map_.next_key()? {
10026                    match k {
10027                        GeneratedField::ActorSplits => {
10028                            if actor_splits__.is_some() {
10029                                return Err(serde::de::Error::duplicate_field("actorSplits"));
10030                            }
10031                            actor_splits__ = Some(
10032                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10033                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
10034                            );
10035                        }
10036                    }
10037                }
10038                Ok(SourceChangeSplitMutation {
10039                    actor_splits: actor_splits__.unwrap_or_default(),
10040                })
10041            }
10042        }
10043        deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
10044    }
10045}
10046impl serde::Serialize for SourceNode {
10047    #[allow(deprecated)]
10048    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10049    where
10050        S: serde::Serializer,
10051    {
10052        use serde::ser::SerializeStruct;
10053        let mut len = 0;
10054        if self.source_inner.is_some() {
10055            len += 1;
10056        }
10057        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
10058        if let Some(v) = self.source_inner.as_ref() {
10059            struct_ser.serialize_field("sourceInner", v)?;
10060        }
10061        struct_ser.end()
10062    }
10063}
10064impl<'de> serde::Deserialize<'de> for SourceNode {
10065    #[allow(deprecated)]
10066    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10067    where
10068        D: serde::Deserializer<'de>,
10069    {
10070        const FIELDS: &[&str] = &[
10071            "source_inner",
10072            "sourceInner",
10073        ];
10074
10075        #[allow(clippy::enum_variant_names)]
10076        enum GeneratedField {
10077            SourceInner,
10078        }
10079        impl<'de> serde::Deserialize<'de> for GeneratedField {
10080            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10081            where
10082                D: serde::Deserializer<'de>,
10083            {
10084                struct GeneratedVisitor;
10085
10086                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10087                    type Value = GeneratedField;
10088
10089                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10090                        write!(formatter, "expected one of: {:?}", &FIELDS)
10091                    }
10092
10093                    #[allow(unused_variables)]
10094                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10095                    where
10096                        E: serde::de::Error,
10097                    {
10098                        match value {
10099                            "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
10100                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10101                        }
10102                    }
10103                }
10104                deserializer.deserialize_identifier(GeneratedVisitor)
10105            }
10106        }
10107        struct GeneratedVisitor;
10108        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10109            type Value = SourceNode;
10110
10111            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10112                formatter.write_str("struct stream_plan.SourceNode")
10113            }
10114
10115            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
10116                where
10117                    V: serde::de::MapAccess<'de>,
10118            {
10119                let mut source_inner__ = None;
10120                while let Some(k) = map_.next_key()? {
10121                    match k {
10122                        GeneratedField::SourceInner => {
10123                            if source_inner__.is_some() {
10124                                return Err(serde::de::Error::duplicate_field("sourceInner"));
10125                            }
10126                            source_inner__ = map_.next_value()?;
10127                        }
10128                    }
10129                }
10130                Ok(SourceNode {
10131                    source_inner: source_inner__,
10132                })
10133            }
10134        }
10135        deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
10136    }
10137}
10138impl serde::Serialize for StartFragmentBackfillMutation {
10139    #[allow(deprecated)]
10140    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10141    where
10142        S: serde::Serializer,
10143    {
10144        use serde::ser::SerializeStruct;
10145        let mut len = 0;
10146        if !self.fragment_ids.is_empty() {
10147            len += 1;
10148        }
10149        let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
10150        if !self.fragment_ids.is_empty() {
10151            struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
10152        }
10153        struct_ser.end()
10154    }
10155}
10156impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
10157    #[allow(deprecated)]
10158    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10159    where
10160        D: serde::Deserializer<'de>,
10161    {
10162        const FIELDS: &[&str] = &[
10163            "fragment_ids",
10164            "fragmentIds",
10165        ];
10166
10167        #[allow(clippy::enum_variant_names)]
10168        enum GeneratedField {
10169            FragmentIds,
10170        }
10171        impl<'de> serde::Deserialize<'de> for GeneratedField {
10172            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10173            where
10174                D: serde::Deserializer<'de>,
10175            {
10176                struct GeneratedVisitor;
10177
10178                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10179                    type Value = GeneratedField;
10180
10181                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10182                        write!(formatter, "expected one of: {:?}", &FIELDS)
10183                    }
10184
10185                    #[allow(unused_variables)]
10186                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10187                    where
10188                        E: serde::de::Error,
10189                    {
10190                        match value {
10191                            "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10192                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10193                        }
10194                    }
10195                }
10196                deserializer.deserialize_identifier(GeneratedVisitor)
10197            }
10198        }
10199        struct GeneratedVisitor;
10200        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10201            type Value = StartFragmentBackfillMutation;
10202
10203            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10204                formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10205            }
10206
10207            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10208                where
10209                    V: serde::de::MapAccess<'de>,
10210            {
10211                let mut fragment_ids__ = None;
10212                while let Some(k) = map_.next_key()? {
10213                    match k {
10214                        GeneratedField::FragmentIds => {
10215                            if fragment_ids__.is_some() {
10216                                return Err(serde::de::Error::duplicate_field("fragmentIds"));
10217                            }
10218                            fragment_ids__ = 
10219                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10220                                    .into_iter().map(|x| x.0).collect())
10221                            ;
10222                        }
10223                    }
10224                }
10225                Ok(StartFragmentBackfillMutation {
10226                    fragment_ids: fragment_ids__.unwrap_or_default(),
10227                })
10228            }
10229        }
10230        deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10231    }
10232}
10233impl serde::Serialize for StopMutation {
10234    #[allow(deprecated)]
10235    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10236    where
10237        S: serde::Serializer,
10238    {
10239        use serde::ser::SerializeStruct;
10240        let mut len = 0;
10241        if !self.actors.is_empty() {
10242            len += 1;
10243        }
10244        if !self.dropped_sink_fragments.is_empty() {
10245            len += 1;
10246        }
10247        let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10248        if !self.actors.is_empty() {
10249            struct_ser.serialize_field("actors", &self.actors)?;
10250        }
10251        if !self.dropped_sink_fragments.is_empty() {
10252            struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10253        }
10254        struct_ser.end()
10255    }
10256}
10257impl<'de> serde::Deserialize<'de> for StopMutation {
10258    #[allow(deprecated)]
10259    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10260    where
10261        D: serde::Deserializer<'de>,
10262    {
10263        const FIELDS: &[&str] = &[
10264            "actors",
10265            "dropped_sink_fragments",
10266            "droppedSinkFragments",
10267        ];
10268
10269        #[allow(clippy::enum_variant_names)]
10270        enum GeneratedField {
10271            Actors,
10272            DroppedSinkFragments,
10273        }
10274        impl<'de> serde::Deserialize<'de> for GeneratedField {
10275            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10276            where
10277                D: serde::Deserializer<'de>,
10278            {
10279                struct GeneratedVisitor;
10280
10281                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10282                    type Value = GeneratedField;
10283
10284                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10285                        write!(formatter, "expected one of: {:?}", &FIELDS)
10286                    }
10287
10288                    #[allow(unused_variables)]
10289                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10290                    where
10291                        E: serde::de::Error,
10292                    {
10293                        match value {
10294                            "actors" => Ok(GeneratedField::Actors),
10295                            "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10296                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10297                        }
10298                    }
10299                }
10300                deserializer.deserialize_identifier(GeneratedVisitor)
10301            }
10302        }
10303        struct GeneratedVisitor;
10304        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10305            type Value = StopMutation;
10306
10307            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10308                formatter.write_str("struct stream_plan.StopMutation")
10309            }
10310
10311            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10312                where
10313                    V: serde::de::MapAccess<'de>,
10314            {
10315                let mut actors__ = None;
10316                let mut dropped_sink_fragments__ = None;
10317                while let Some(k) = map_.next_key()? {
10318                    match k {
10319                        GeneratedField::Actors => {
10320                            if actors__.is_some() {
10321                                return Err(serde::de::Error::duplicate_field("actors"));
10322                            }
10323                            actors__ = 
10324                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10325                                    .into_iter().map(|x| x.0).collect())
10326                            ;
10327                        }
10328                        GeneratedField::DroppedSinkFragments => {
10329                            if dropped_sink_fragments__.is_some() {
10330                                return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10331                            }
10332                            dropped_sink_fragments__ = 
10333                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10334                                    .into_iter().map(|x| x.0).collect())
10335                            ;
10336                        }
10337                    }
10338                }
10339                Ok(StopMutation {
10340                    actors: actors__.unwrap_or_default(),
10341                    dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10342                })
10343            }
10344        }
10345        deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10346    }
10347}
10348impl serde::Serialize for StreamActor {
10349    #[allow(deprecated)]
10350    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10351    where
10352        S: serde::Serializer,
10353    {
10354        use serde::ser::SerializeStruct;
10355        let mut len = 0;
10356        if self.actor_id != 0 {
10357            len += 1;
10358        }
10359        if self.fragment_id != 0 {
10360            len += 1;
10361        }
10362        if !self.dispatcher.is_empty() {
10363            len += 1;
10364        }
10365        if self.vnode_bitmap.is_some() {
10366            len += 1;
10367        }
10368        if !self.mview_definition.is_empty() {
10369            len += 1;
10370        }
10371        if self.expr_context.is_some() {
10372            len += 1;
10373        }
10374        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10375        if self.actor_id != 0 {
10376            struct_ser.serialize_field("actorId", &self.actor_id)?;
10377        }
10378        if self.fragment_id != 0 {
10379            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10380        }
10381        if !self.dispatcher.is_empty() {
10382            struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10383        }
10384        if let Some(v) = self.vnode_bitmap.as_ref() {
10385            struct_ser.serialize_field("vnodeBitmap", v)?;
10386        }
10387        if !self.mview_definition.is_empty() {
10388            struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10389        }
10390        if let Some(v) = self.expr_context.as_ref() {
10391            struct_ser.serialize_field("exprContext", v)?;
10392        }
10393        struct_ser.end()
10394    }
10395}
10396impl<'de> serde::Deserialize<'de> for StreamActor {
10397    #[allow(deprecated)]
10398    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10399    where
10400        D: serde::Deserializer<'de>,
10401    {
10402        const FIELDS: &[&str] = &[
10403            "actor_id",
10404            "actorId",
10405            "fragment_id",
10406            "fragmentId",
10407            "dispatcher",
10408            "vnode_bitmap",
10409            "vnodeBitmap",
10410            "mview_definition",
10411            "mviewDefinition",
10412            "expr_context",
10413            "exprContext",
10414        ];
10415
10416        #[allow(clippy::enum_variant_names)]
10417        enum GeneratedField {
10418            ActorId,
10419            FragmentId,
10420            Dispatcher,
10421            VnodeBitmap,
10422            MviewDefinition,
10423            ExprContext,
10424        }
10425        impl<'de> serde::Deserialize<'de> for GeneratedField {
10426            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10427            where
10428                D: serde::Deserializer<'de>,
10429            {
10430                struct GeneratedVisitor;
10431
10432                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10433                    type Value = GeneratedField;
10434
10435                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10436                        write!(formatter, "expected one of: {:?}", &FIELDS)
10437                    }
10438
10439                    #[allow(unused_variables)]
10440                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10441                    where
10442                        E: serde::de::Error,
10443                    {
10444                        match value {
10445                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10446                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10447                            "dispatcher" => Ok(GeneratedField::Dispatcher),
10448                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10449                            "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10450                            "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10451                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10452                        }
10453                    }
10454                }
10455                deserializer.deserialize_identifier(GeneratedVisitor)
10456            }
10457        }
10458        struct GeneratedVisitor;
10459        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10460            type Value = StreamActor;
10461
10462            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10463                formatter.write_str("struct stream_plan.StreamActor")
10464            }
10465
10466            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10467                where
10468                    V: serde::de::MapAccess<'de>,
10469            {
10470                let mut actor_id__ = None;
10471                let mut fragment_id__ = None;
10472                let mut dispatcher__ = None;
10473                let mut vnode_bitmap__ = None;
10474                let mut mview_definition__ = None;
10475                let mut expr_context__ = None;
10476                while let Some(k) = map_.next_key()? {
10477                    match k {
10478                        GeneratedField::ActorId => {
10479                            if actor_id__.is_some() {
10480                                return Err(serde::de::Error::duplicate_field("actorId"));
10481                            }
10482                            actor_id__ = 
10483                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10484                            ;
10485                        }
10486                        GeneratedField::FragmentId => {
10487                            if fragment_id__.is_some() {
10488                                return Err(serde::de::Error::duplicate_field("fragmentId"));
10489                            }
10490                            fragment_id__ = 
10491                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10492                            ;
10493                        }
10494                        GeneratedField::Dispatcher => {
10495                            if dispatcher__.is_some() {
10496                                return Err(serde::de::Error::duplicate_field("dispatcher"));
10497                            }
10498                            dispatcher__ = Some(map_.next_value()?);
10499                        }
10500                        GeneratedField::VnodeBitmap => {
10501                            if vnode_bitmap__.is_some() {
10502                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10503                            }
10504                            vnode_bitmap__ = map_.next_value()?;
10505                        }
10506                        GeneratedField::MviewDefinition => {
10507                            if mview_definition__.is_some() {
10508                                return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10509                            }
10510                            mview_definition__ = Some(map_.next_value()?);
10511                        }
10512                        GeneratedField::ExprContext => {
10513                            if expr_context__.is_some() {
10514                                return Err(serde::de::Error::duplicate_field("exprContext"));
10515                            }
10516                            expr_context__ = map_.next_value()?;
10517                        }
10518                    }
10519                }
10520                Ok(StreamActor {
10521                    actor_id: actor_id__.unwrap_or_default(),
10522                    fragment_id: fragment_id__.unwrap_or_default(),
10523                    dispatcher: dispatcher__.unwrap_or_default(),
10524                    vnode_bitmap: vnode_bitmap__,
10525                    mview_definition: mview_definition__.unwrap_or_default(),
10526                    expr_context: expr_context__,
10527                })
10528            }
10529        }
10530        deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10531    }
10532}
10533impl serde::Serialize for StreamCdcScanNode {
10534    #[allow(deprecated)]
10535    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10536    where
10537        S: serde::Serializer,
10538    {
10539        use serde::ser::SerializeStruct;
10540        let mut len = 0;
10541        if self.table_id != 0 {
10542            len += 1;
10543        }
10544        if !self.upstream_column_ids.is_empty() {
10545            len += 1;
10546        }
10547        if !self.output_indices.is_empty() {
10548            len += 1;
10549        }
10550        if self.state_table.is_some() {
10551            len += 1;
10552        }
10553        if self.cdc_table_desc.is_some() {
10554            len += 1;
10555        }
10556        if self.rate_limit.is_some() {
10557            len += 1;
10558        }
10559        if self.disable_backfill {
10560            len += 1;
10561        }
10562        if self.options.is_some() {
10563            len += 1;
10564        }
10565        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
10566        if self.table_id != 0 {
10567            struct_ser.serialize_field("tableId", &self.table_id)?;
10568        }
10569        if !self.upstream_column_ids.is_empty() {
10570            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
10571        }
10572        if !self.output_indices.is_empty() {
10573            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
10574        }
10575        if let Some(v) = self.state_table.as_ref() {
10576            struct_ser.serialize_field("stateTable", v)?;
10577        }
10578        if let Some(v) = self.cdc_table_desc.as_ref() {
10579            struct_ser.serialize_field("cdcTableDesc", v)?;
10580        }
10581        if let Some(v) = self.rate_limit.as_ref() {
10582            struct_ser.serialize_field("rateLimit", v)?;
10583        }
10584        if self.disable_backfill {
10585            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10586        }
10587        if let Some(v) = self.options.as_ref() {
10588            struct_ser.serialize_field("options", v)?;
10589        }
10590        struct_ser.end()
10591    }
10592}
10593impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
10594    #[allow(deprecated)]
10595    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10596    where
10597        D: serde::Deserializer<'de>,
10598    {
10599        const FIELDS: &[&str] = &[
10600            "table_id",
10601            "tableId",
10602            "upstream_column_ids",
10603            "upstreamColumnIds",
10604            "output_indices",
10605            "outputIndices",
10606            "state_table",
10607            "stateTable",
10608            "cdc_table_desc",
10609            "cdcTableDesc",
10610            "rate_limit",
10611            "rateLimit",
10612            "disable_backfill",
10613            "disableBackfill",
10614            "options",
10615        ];
10616
10617        #[allow(clippy::enum_variant_names)]
10618        enum GeneratedField {
10619            TableId,
10620            UpstreamColumnIds,
10621            OutputIndices,
10622            StateTable,
10623            CdcTableDesc,
10624            RateLimit,
10625            DisableBackfill,
10626            Options,
10627        }
10628        impl<'de> serde::Deserialize<'de> for GeneratedField {
10629            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10630            where
10631                D: serde::Deserializer<'de>,
10632            {
10633                struct GeneratedVisitor;
10634
10635                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10636                    type Value = GeneratedField;
10637
10638                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10639                        write!(formatter, "expected one of: {:?}", &FIELDS)
10640                    }
10641
10642                    #[allow(unused_variables)]
10643                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10644                    where
10645                        E: serde::de::Error,
10646                    {
10647                        match value {
10648                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
10649                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
10650                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
10651                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10652                            "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
10653                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10654                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10655                            "options" => Ok(GeneratedField::Options),
10656                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10657                        }
10658                    }
10659                }
10660                deserializer.deserialize_identifier(GeneratedVisitor)
10661            }
10662        }
10663        struct GeneratedVisitor;
10664        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10665            type Value = StreamCdcScanNode;
10666
10667            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10668                formatter.write_str("struct stream_plan.StreamCdcScanNode")
10669            }
10670
10671            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10672                where
10673                    V: serde::de::MapAccess<'de>,
10674            {
10675                let mut table_id__ = None;
10676                let mut upstream_column_ids__ = None;
10677                let mut output_indices__ = None;
10678                let mut state_table__ = None;
10679                let mut cdc_table_desc__ = None;
10680                let mut rate_limit__ = None;
10681                let mut disable_backfill__ = None;
10682                let mut options__ = None;
10683                while let Some(k) = map_.next_key()? {
10684                    match k {
10685                        GeneratedField::TableId => {
10686                            if table_id__.is_some() {
10687                                return Err(serde::de::Error::duplicate_field("tableId"));
10688                            }
10689                            table_id__ = 
10690                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10691                            ;
10692                        }
10693                        GeneratedField::UpstreamColumnIds => {
10694                            if upstream_column_ids__.is_some() {
10695                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10696                            }
10697                            upstream_column_ids__ = 
10698                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10699                                    .into_iter().map(|x| x.0).collect())
10700                            ;
10701                        }
10702                        GeneratedField::OutputIndices => {
10703                            if output_indices__.is_some() {
10704                                return Err(serde::de::Error::duplicate_field("outputIndices"));
10705                            }
10706                            output_indices__ = 
10707                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10708                                    .into_iter().map(|x| x.0).collect())
10709                            ;
10710                        }
10711                        GeneratedField::StateTable => {
10712                            if state_table__.is_some() {
10713                                return Err(serde::de::Error::duplicate_field("stateTable"));
10714                            }
10715                            state_table__ = map_.next_value()?;
10716                        }
10717                        GeneratedField::CdcTableDesc => {
10718                            if cdc_table_desc__.is_some() {
10719                                return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10720                            }
10721                            cdc_table_desc__ = map_.next_value()?;
10722                        }
10723                        GeneratedField::RateLimit => {
10724                            if rate_limit__.is_some() {
10725                                return Err(serde::de::Error::duplicate_field("rateLimit"));
10726                            }
10727                            rate_limit__ = 
10728                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10729                            ;
10730                        }
10731                        GeneratedField::DisableBackfill => {
10732                            if disable_backfill__.is_some() {
10733                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10734                            }
10735                            disable_backfill__ = Some(map_.next_value()?);
10736                        }
10737                        GeneratedField::Options => {
10738                            if options__.is_some() {
10739                                return Err(serde::de::Error::duplicate_field("options"));
10740                            }
10741                            options__ = map_.next_value()?;
10742                        }
10743                    }
10744                }
10745                Ok(StreamCdcScanNode {
10746                    table_id: table_id__.unwrap_or_default(),
10747                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10748                    output_indices: output_indices__.unwrap_or_default(),
10749                    state_table: state_table__,
10750                    cdc_table_desc: cdc_table_desc__,
10751                    rate_limit: rate_limit__,
10752                    disable_backfill: disable_backfill__.unwrap_or_default(),
10753                    options: options__,
10754                })
10755            }
10756        }
10757        deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10758    }
10759}
10760impl serde::Serialize for StreamCdcScanOptions {
10761    #[allow(deprecated)]
10762    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10763    where
10764        S: serde::Serializer,
10765    {
10766        use serde::ser::SerializeStruct;
10767        let mut len = 0;
10768        if self.disable_backfill {
10769            len += 1;
10770        }
10771        if self.snapshot_barrier_interval != 0 {
10772            len += 1;
10773        }
10774        if self.snapshot_batch_size != 0 {
10775            len += 1;
10776        }
10777        if self.backfill_parallelism != 0 {
10778            len += 1;
10779        }
10780        if self.backfill_num_rows_per_split != 0 {
10781            len += 1;
10782        }
10783        if self.backfill_as_even_splits {
10784            len += 1;
10785        }
10786        if self.backfill_split_pk_column_index != 0 {
10787            len += 1;
10788        }
10789        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10790        if self.disable_backfill {
10791            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10792        }
10793        if self.snapshot_barrier_interval != 0 {
10794            struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10795        }
10796        if self.snapshot_batch_size != 0 {
10797            struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10798        }
10799        if self.backfill_parallelism != 0 {
10800            struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
10801        }
10802        if self.backfill_num_rows_per_split != 0 {
10803            #[allow(clippy::needless_borrow)]
10804            #[allow(clippy::needless_borrows_for_generic_args)]
10805            struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
10806        }
10807        if self.backfill_as_even_splits {
10808            struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
10809        }
10810        if self.backfill_split_pk_column_index != 0 {
10811            struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
10812        }
10813        struct_ser.end()
10814    }
10815}
10816impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10817    #[allow(deprecated)]
10818    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10819    where
10820        D: serde::Deserializer<'de>,
10821    {
10822        const FIELDS: &[&str] = &[
10823            "disable_backfill",
10824            "disableBackfill",
10825            "snapshot_barrier_interval",
10826            "snapshotBarrierInterval",
10827            "snapshot_batch_size",
10828            "snapshotBatchSize",
10829            "backfill_parallelism",
10830            "backfillParallelism",
10831            "backfill_num_rows_per_split",
10832            "backfillNumRowsPerSplit",
10833            "backfill_as_even_splits",
10834            "backfillAsEvenSplits",
10835            "backfill_split_pk_column_index",
10836            "backfillSplitPkColumnIndex",
10837        ];
10838
10839        #[allow(clippy::enum_variant_names)]
10840        enum GeneratedField {
10841            DisableBackfill,
10842            SnapshotBarrierInterval,
10843            SnapshotBatchSize,
10844            BackfillParallelism,
10845            BackfillNumRowsPerSplit,
10846            BackfillAsEvenSplits,
10847            BackfillSplitPkColumnIndex,
10848        }
10849        impl<'de> serde::Deserialize<'de> for GeneratedField {
10850            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10851            where
10852                D: serde::Deserializer<'de>,
10853            {
10854                struct GeneratedVisitor;
10855
10856                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10857                    type Value = GeneratedField;
10858
10859                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10860                        write!(formatter, "expected one of: {:?}", &FIELDS)
10861                    }
10862
10863                    #[allow(unused_variables)]
10864                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10865                    where
10866                        E: serde::de::Error,
10867                    {
10868                        match value {
10869                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10870                            "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10871                            "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10872                            "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
10873                            "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
10874                            "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
10875                            "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
10876                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10877                        }
10878                    }
10879                }
10880                deserializer.deserialize_identifier(GeneratedVisitor)
10881            }
10882        }
10883        struct GeneratedVisitor;
10884        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10885            type Value = StreamCdcScanOptions;
10886
10887            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10888                formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10889            }
10890
10891            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10892                where
10893                    V: serde::de::MapAccess<'de>,
10894            {
10895                let mut disable_backfill__ = None;
10896                let mut snapshot_barrier_interval__ = None;
10897                let mut snapshot_batch_size__ = None;
10898                let mut backfill_parallelism__ = None;
10899                let mut backfill_num_rows_per_split__ = None;
10900                let mut backfill_as_even_splits__ = None;
10901                let mut backfill_split_pk_column_index__ = None;
10902                while let Some(k) = map_.next_key()? {
10903                    match k {
10904                        GeneratedField::DisableBackfill => {
10905                            if disable_backfill__.is_some() {
10906                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10907                            }
10908                            disable_backfill__ = Some(map_.next_value()?);
10909                        }
10910                        GeneratedField::SnapshotBarrierInterval => {
10911                            if snapshot_barrier_interval__.is_some() {
10912                                return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10913                            }
10914                            snapshot_barrier_interval__ = 
10915                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10916                            ;
10917                        }
10918                        GeneratedField::SnapshotBatchSize => {
10919                            if snapshot_batch_size__.is_some() {
10920                                return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10921                            }
10922                            snapshot_batch_size__ = 
10923                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10924                            ;
10925                        }
10926                        GeneratedField::BackfillParallelism => {
10927                            if backfill_parallelism__.is_some() {
10928                                return Err(serde::de::Error::duplicate_field("backfillParallelism"));
10929                            }
10930                            backfill_parallelism__ = 
10931                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10932                            ;
10933                        }
10934                        GeneratedField::BackfillNumRowsPerSplit => {
10935                            if backfill_num_rows_per_split__.is_some() {
10936                                return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
10937                            }
10938                            backfill_num_rows_per_split__ = 
10939                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10940                            ;
10941                        }
10942                        GeneratedField::BackfillAsEvenSplits => {
10943                            if backfill_as_even_splits__.is_some() {
10944                                return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
10945                            }
10946                            backfill_as_even_splits__ = Some(map_.next_value()?);
10947                        }
10948                        GeneratedField::BackfillSplitPkColumnIndex => {
10949                            if backfill_split_pk_column_index__.is_some() {
10950                                return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
10951                            }
10952                            backfill_split_pk_column_index__ = 
10953                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10954                            ;
10955                        }
10956                    }
10957                }
10958                Ok(StreamCdcScanOptions {
10959                    disable_backfill: disable_backfill__.unwrap_or_default(),
10960                    snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10961                    snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10962                    backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
10963                    backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
10964                    backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
10965                    backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
10966                })
10967            }
10968        }
10969        deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10970    }
10971}
10972impl serde::Serialize for StreamContext {
10973    #[allow(deprecated)]
10974    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10975    where
10976        S: serde::Serializer,
10977    {
10978        use serde::ser::SerializeStruct;
10979        let mut len = 0;
10980        if !self.timezone.is_empty() {
10981            len += 1;
10982        }
10983        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10984        if !self.timezone.is_empty() {
10985            struct_ser.serialize_field("timezone", &self.timezone)?;
10986        }
10987        struct_ser.end()
10988    }
10989}
10990impl<'de> serde::Deserialize<'de> for StreamContext {
10991    #[allow(deprecated)]
10992    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10993    where
10994        D: serde::Deserializer<'de>,
10995    {
10996        const FIELDS: &[&str] = &[
10997            "timezone",
10998        ];
10999
11000        #[allow(clippy::enum_variant_names)]
11001        enum GeneratedField {
11002            Timezone,
11003        }
11004        impl<'de> serde::Deserialize<'de> for GeneratedField {
11005            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11006            where
11007                D: serde::Deserializer<'de>,
11008            {
11009                struct GeneratedVisitor;
11010
11011                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11012                    type Value = GeneratedField;
11013
11014                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11015                        write!(formatter, "expected one of: {:?}", &FIELDS)
11016                    }
11017
11018                    #[allow(unused_variables)]
11019                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11020                    where
11021                        E: serde::de::Error,
11022                    {
11023                        match value {
11024                            "timezone" => Ok(GeneratedField::Timezone),
11025                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11026                        }
11027                    }
11028                }
11029                deserializer.deserialize_identifier(GeneratedVisitor)
11030            }
11031        }
11032        struct GeneratedVisitor;
11033        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11034            type Value = StreamContext;
11035
11036            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11037                formatter.write_str("struct stream_plan.StreamContext")
11038            }
11039
11040            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
11041                where
11042                    V: serde::de::MapAccess<'de>,
11043            {
11044                let mut timezone__ = None;
11045                while let Some(k) = map_.next_key()? {
11046                    match k {
11047                        GeneratedField::Timezone => {
11048                            if timezone__.is_some() {
11049                                return Err(serde::de::Error::duplicate_field("timezone"));
11050                            }
11051                            timezone__ = Some(map_.next_value()?);
11052                        }
11053                    }
11054                }
11055                Ok(StreamContext {
11056                    timezone: timezone__.unwrap_or_default(),
11057                })
11058            }
11059        }
11060        deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
11061    }
11062}
11063impl serde::Serialize for StreamFragmentGraph {
11064    #[allow(deprecated)]
11065    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11066    where
11067        S: serde::Serializer,
11068    {
11069        use serde::ser::SerializeStruct;
11070        let mut len = 0;
11071        if !self.fragments.is_empty() {
11072            len += 1;
11073        }
11074        if !self.edges.is_empty() {
11075            len += 1;
11076        }
11077        if !self.dependent_table_ids.is_empty() {
11078            len += 1;
11079        }
11080        if self.table_ids_cnt != 0 {
11081            len += 1;
11082        }
11083        if self.ctx.is_some() {
11084            len += 1;
11085        }
11086        if self.parallelism.is_some() {
11087            len += 1;
11088        }
11089        if self.max_parallelism != 0 {
11090            len += 1;
11091        }
11092        if self.backfill_order.is_some() {
11093            len += 1;
11094        }
11095        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
11096        if !self.fragments.is_empty() {
11097            struct_ser.serialize_field("fragments", &self.fragments)?;
11098        }
11099        if !self.edges.is_empty() {
11100            struct_ser.serialize_field("edges", &self.edges)?;
11101        }
11102        if !self.dependent_table_ids.is_empty() {
11103            struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
11104        }
11105        if self.table_ids_cnt != 0 {
11106            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11107        }
11108        if let Some(v) = self.ctx.as_ref() {
11109            struct_ser.serialize_field("ctx", v)?;
11110        }
11111        if let Some(v) = self.parallelism.as_ref() {
11112            struct_ser.serialize_field("parallelism", v)?;
11113        }
11114        if self.max_parallelism != 0 {
11115            struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11116        }
11117        if let Some(v) = self.backfill_order.as_ref() {
11118            struct_ser.serialize_field("backfillOrder", v)?;
11119        }
11120        struct_ser.end()
11121    }
11122}
11123impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
11124    #[allow(deprecated)]
11125    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11126    where
11127        D: serde::Deserializer<'de>,
11128    {
11129        const FIELDS: &[&str] = &[
11130            "fragments",
11131            "edges",
11132            "dependent_table_ids",
11133            "dependentTableIds",
11134            "table_ids_cnt",
11135            "tableIdsCnt",
11136            "ctx",
11137            "parallelism",
11138            "max_parallelism",
11139            "maxParallelism",
11140            "backfill_order",
11141            "backfillOrder",
11142        ];
11143
11144        #[allow(clippy::enum_variant_names)]
11145        enum GeneratedField {
11146            Fragments,
11147            Edges,
11148            DependentTableIds,
11149            TableIdsCnt,
11150            Ctx,
11151            Parallelism,
11152            MaxParallelism,
11153            BackfillOrder,
11154        }
11155        impl<'de> serde::Deserialize<'de> for GeneratedField {
11156            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11157            where
11158                D: serde::Deserializer<'de>,
11159            {
11160                struct GeneratedVisitor;
11161
11162                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11163                    type Value = GeneratedField;
11164
11165                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11166                        write!(formatter, "expected one of: {:?}", &FIELDS)
11167                    }
11168
11169                    #[allow(unused_variables)]
11170                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11171                    where
11172                        E: serde::de::Error,
11173                    {
11174                        match value {
11175                            "fragments" => Ok(GeneratedField::Fragments),
11176                            "edges" => Ok(GeneratedField::Edges),
11177                            "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
11178                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11179                            "ctx" => Ok(GeneratedField::Ctx),
11180                            "parallelism" => Ok(GeneratedField::Parallelism),
11181                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11182                            "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
11183                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11184                        }
11185                    }
11186                }
11187                deserializer.deserialize_identifier(GeneratedVisitor)
11188            }
11189        }
11190        struct GeneratedVisitor;
11191        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11192            type Value = StreamFragmentGraph;
11193
11194            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11195                formatter.write_str("struct stream_plan.StreamFragmentGraph")
11196            }
11197
11198            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11199                where
11200                    V: serde::de::MapAccess<'de>,
11201            {
11202                let mut fragments__ = None;
11203                let mut edges__ = None;
11204                let mut dependent_table_ids__ = None;
11205                let mut table_ids_cnt__ = None;
11206                let mut ctx__ = None;
11207                let mut parallelism__ = None;
11208                let mut max_parallelism__ = None;
11209                let mut backfill_order__ = None;
11210                while let Some(k) = map_.next_key()? {
11211                    match k {
11212                        GeneratedField::Fragments => {
11213                            if fragments__.is_some() {
11214                                return Err(serde::de::Error::duplicate_field("fragments"));
11215                            }
11216                            fragments__ = Some(
11217                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11218                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
11219                            );
11220                        }
11221                        GeneratedField::Edges => {
11222                            if edges__.is_some() {
11223                                return Err(serde::de::Error::duplicate_field("edges"));
11224                            }
11225                            edges__ = Some(map_.next_value()?);
11226                        }
11227                        GeneratedField::DependentTableIds => {
11228                            if dependent_table_ids__.is_some() {
11229                                return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11230                            }
11231                            dependent_table_ids__ = 
11232                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11233                                    .into_iter().map(|x| x.0).collect())
11234                            ;
11235                        }
11236                        GeneratedField::TableIdsCnt => {
11237                            if table_ids_cnt__.is_some() {
11238                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11239                            }
11240                            table_ids_cnt__ = 
11241                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11242                            ;
11243                        }
11244                        GeneratedField::Ctx => {
11245                            if ctx__.is_some() {
11246                                return Err(serde::de::Error::duplicate_field("ctx"));
11247                            }
11248                            ctx__ = map_.next_value()?;
11249                        }
11250                        GeneratedField::Parallelism => {
11251                            if parallelism__.is_some() {
11252                                return Err(serde::de::Error::duplicate_field("parallelism"));
11253                            }
11254                            parallelism__ = map_.next_value()?;
11255                        }
11256                        GeneratedField::MaxParallelism => {
11257                            if max_parallelism__.is_some() {
11258                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
11259                            }
11260                            max_parallelism__ = 
11261                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11262                            ;
11263                        }
11264                        GeneratedField::BackfillOrder => {
11265                            if backfill_order__.is_some() {
11266                                return Err(serde::de::Error::duplicate_field("backfillOrder"));
11267                            }
11268                            backfill_order__ = map_.next_value()?;
11269                        }
11270                    }
11271                }
11272                Ok(StreamFragmentGraph {
11273                    fragments: fragments__.unwrap_or_default(),
11274                    edges: edges__.unwrap_or_default(),
11275                    dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11276                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11277                    ctx: ctx__,
11278                    parallelism: parallelism__,
11279                    max_parallelism: max_parallelism__.unwrap_or_default(),
11280                    backfill_order: backfill_order__,
11281                })
11282            }
11283        }
11284        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11285    }
11286}
11287impl serde::Serialize for stream_fragment_graph::Parallelism {
11288    #[allow(deprecated)]
11289    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11290    where
11291        S: serde::Serializer,
11292    {
11293        use serde::ser::SerializeStruct;
11294        let mut len = 0;
11295        if self.parallelism != 0 {
11296            len += 1;
11297        }
11298        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11299        if self.parallelism != 0 {
11300            #[allow(clippy::needless_borrow)]
11301            #[allow(clippy::needless_borrows_for_generic_args)]
11302            struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11303        }
11304        struct_ser.end()
11305    }
11306}
11307impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11308    #[allow(deprecated)]
11309    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11310    where
11311        D: serde::Deserializer<'de>,
11312    {
11313        const FIELDS: &[&str] = &[
11314            "parallelism",
11315        ];
11316
11317        #[allow(clippy::enum_variant_names)]
11318        enum GeneratedField {
11319            Parallelism,
11320        }
11321        impl<'de> serde::Deserialize<'de> for GeneratedField {
11322            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11323            where
11324                D: serde::Deserializer<'de>,
11325            {
11326                struct GeneratedVisitor;
11327
11328                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11329                    type Value = GeneratedField;
11330
11331                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11332                        write!(formatter, "expected one of: {:?}", &FIELDS)
11333                    }
11334
11335                    #[allow(unused_variables)]
11336                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11337                    where
11338                        E: serde::de::Error,
11339                    {
11340                        match value {
11341                            "parallelism" => Ok(GeneratedField::Parallelism),
11342                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11343                        }
11344                    }
11345                }
11346                deserializer.deserialize_identifier(GeneratedVisitor)
11347            }
11348        }
11349        struct GeneratedVisitor;
11350        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11351            type Value = stream_fragment_graph::Parallelism;
11352
11353            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11354                formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11355            }
11356
11357            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11358                where
11359                    V: serde::de::MapAccess<'de>,
11360            {
11361                let mut parallelism__ = None;
11362                while let Some(k) = map_.next_key()? {
11363                    match k {
11364                        GeneratedField::Parallelism => {
11365                            if parallelism__.is_some() {
11366                                return Err(serde::de::Error::duplicate_field("parallelism"));
11367                            }
11368                            parallelism__ = 
11369                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11370                            ;
11371                        }
11372                    }
11373                }
11374                Ok(stream_fragment_graph::Parallelism {
11375                    parallelism: parallelism__.unwrap_or_default(),
11376                })
11377            }
11378        }
11379        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11380    }
11381}
11382impl serde::Serialize for stream_fragment_graph::StreamFragment {
11383    #[allow(deprecated)]
11384    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11385    where
11386        S: serde::Serializer,
11387    {
11388        use serde::ser::SerializeStruct;
11389        let mut len = 0;
11390        if self.fragment_id != 0 {
11391            len += 1;
11392        }
11393        if self.node.is_some() {
11394            len += 1;
11395        }
11396        if self.fragment_type_mask != 0 {
11397            len += 1;
11398        }
11399        if self.requires_singleton {
11400            len += 1;
11401        }
11402        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11403        if self.fragment_id != 0 {
11404            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11405        }
11406        if let Some(v) = self.node.as_ref() {
11407            struct_ser.serialize_field("node", v)?;
11408        }
11409        if self.fragment_type_mask != 0 {
11410            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11411        }
11412        if self.requires_singleton {
11413            struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11414        }
11415        struct_ser.end()
11416    }
11417}
11418impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11419    #[allow(deprecated)]
11420    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11421    where
11422        D: serde::Deserializer<'de>,
11423    {
11424        const FIELDS: &[&str] = &[
11425            "fragment_id",
11426            "fragmentId",
11427            "node",
11428            "fragment_type_mask",
11429            "fragmentTypeMask",
11430            "requires_singleton",
11431            "requiresSingleton",
11432        ];
11433
11434        #[allow(clippy::enum_variant_names)]
11435        enum GeneratedField {
11436            FragmentId,
11437            Node,
11438            FragmentTypeMask,
11439            RequiresSingleton,
11440        }
11441        impl<'de> serde::Deserialize<'de> for GeneratedField {
11442            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11443            where
11444                D: serde::Deserializer<'de>,
11445            {
11446                struct GeneratedVisitor;
11447
11448                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11449                    type Value = GeneratedField;
11450
11451                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11452                        write!(formatter, "expected one of: {:?}", &FIELDS)
11453                    }
11454
11455                    #[allow(unused_variables)]
11456                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11457                    where
11458                        E: serde::de::Error,
11459                    {
11460                        match value {
11461                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11462                            "node" => Ok(GeneratedField::Node),
11463                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11464                            "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11465                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11466                        }
11467                    }
11468                }
11469                deserializer.deserialize_identifier(GeneratedVisitor)
11470            }
11471        }
11472        struct GeneratedVisitor;
11473        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11474            type Value = stream_fragment_graph::StreamFragment;
11475
11476            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11477                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11478            }
11479
11480            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11481                where
11482                    V: serde::de::MapAccess<'de>,
11483            {
11484                let mut fragment_id__ = None;
11485                let mut node__ = None;
11486                let mut fragment_type_mask__ = None;
11487                let mut requires_singleton__ = None;
11488                while let Some(k) = map_.next_key()? {
11489                    match k {
11490                        GeneratedField::FragmentId => {
11491                            if fragment_id__.is_some() {
11492                                return Err(serde::de::Error::duplicate_field("fragmentId"));
11493                            }
11494                            fragment_id__ = 
11495                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11496                            ;
11497                        }
11498                        GeneratedField::Node => {
11499                            if node__.is_some() {
11500                                return Err(serde::de::Error::duplicate_field("node"));
11501                            }
11502                            node__ = map_.next_value()?;
11503                        }
11504                        GeneratedField::FragmentTypeMask => {
11505                            if fragment_type_mask__.is_some() {
11506                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11507                            }
11508                            fragment_type_mask__ = 
11509                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11510                            ;
11511                        }
11512                        GeneratedField::RequiresSingleton => {
11513                            if requires_singleton__.is_some() {
11514                                return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11515                            }
11516                            requires_singleton__ = Some(map_.next_value()?);
11517                        }
11518                    }
11519                }
11520                Ok(stream_fragment_graph::StreamFragment {
11521                    fragment_id: fragment_id__.unwrap_or_default(),
11522                    node: node__,
11523                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11524                    requires_singleton: requires_singleton__.unwrap_or_default(),
11525                })
11526            }
11527        }
11528        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11529    }
11530}
11531impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11532    #[allow(deprecated)]
11533    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11534    where
11535        S: serde::Serializer,
11536    {
11537        use serde::ser::SerializeStruct;
11538        let mut len = 0;
11539        if self.dispatch_strategy.is_some() {
11540            len += 1;
11541        }
11542        if self.link_id != 0 {
11543            len += 1;
11544        }
11545        if self.upstream_id != 0 {
11546            len += 1;
11547        }
11548        if self.downstream_id != 0 {
11549            len += 1;
11550        }
11551        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
11552        if let Some(v) = self.dispatch_strategy.as_ref() {
11553            struct_ser.serialize_field("dispatchStrategy", v)?;
11554        }
11555        if self.link_id != 0 {
11556            #[allow(clippy::needless_borrow)]
11557            #[allow(clippy::needless_borrows_for_generic_args)]
11558            struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
11559        }
11560        if self.upstream_id != 0 {
11561            struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
11562        }
11563        if self.downstream_id != 0 {
11564            struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
11565        }
11566        struct_ser.end()
11567    }
11568}
11569impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
11570    #[allow(deprecated)]
11571    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11572    where
11573        D: serde::Deserializer<'de>,
11574    {
11575        const FIELDS: &[&str] = &[
11576            "dispatch_strategy",
11577            "dispatchStrategy",
11578            "link_id",
11579            "linkId",
11580            "upstream_id",
11581            "upstreamId",
11582            "downstream_id",
11583            "downstreamId",
11584        ];
11585
11586        #[allow(clippy::enum_variant_names)]
11587        enum GeneratedField {
11588            DispatchStrategy,
11589            LinkId,
11590            UpstreamId,
11591            DownstreamId,
11592        }
11593        impl<'de> serde::Deserialize<'de> for GeneratedField {
11594            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11595            where
11596                D: serde::Deserializer<'de>,
11597            {
11598                struct GeneratedVisitor;
11599
11600                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11601                    type Value = GeneratedField;
11602
11603                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11604                        write!(formatter, "expected one of: {:?}", &FIELDS)
11605                    }
11606
11607                    #[allow(unused_variables)]
11608                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11609                    where
11610                        E: serde::de::Error,
11611                    {
11612                        match value {
11613                            "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
11614                            "linkId" | "link_id" => Ok(GeneratedField::LinkId),
11615                            "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
11616                            "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
11617                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11618                        }
11619                    }
11620                }
11621                deserializer.deserialize_identifier(GeneratedVisitor)
11622            }
11623        }
11624        struct GeneratedVisitor;
11625        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11626            type Value = stream_fragment_graph::StreamFragmentEdge;
11627
11628            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11629                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
11630            }
11631
11632            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
11633                where
11634                    V: serde::de::MapAccess<'de>,
11635            {
11636                let mut dispatch_strategy__ = None;
11637                let mut link_id__ = None;
11638                let mut upstream_id__ = None;
11639                let mut downstream_id__ = None;
11640                while let Some(k) = map_.next_key()? {
11641                    match k {
11642                        GeneratedField::DispatchStrategy => {
11643                            if dispatch_strategy__.is_some() {
11644                                return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
11645                            }
11646                            dispatch_strategy__ = map_.next_value()?;
11647                        }
11648                        GeneratedField::LinkId => {
11649                            if link_id__.is_some() {
11650                                return Err(serde::de::Error::duplicate_field("linkId"));
11651                            }
11652                            link_id__ = 
11653                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11654                            ;
11655                        }
11656                        GeneratedField::UpstreamId => {
11657                            if upstream_id__.is_some() {
11658                                return Err(serde::de::Error::duplicate_field("upstreamId"));
11659                            }
11660                            upstream_id__ = 
11661                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11662                            ;
11663                        }
11664                        GeneratedField::DownstreamId => {
11665                            if downstream_id__.is_some() {
11666                                return Err(serde::de::Error::duplicate_field("downstreamId"));
11667                            }
11668                            downstream_id__ = 
11669                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11670                            ;
11671                        }
11672                    }
11673                }
11674                Ok(stream_fragment_graph::StreamFragmentEdge {
11675                    dispatch_strategy: dispatch_strategy__,
11676                    link_id: link_id__.unwrap_or_default(),
11677                    upstream_id: upstream_id__.unwrap_or_default(),
11678                    downstream_id: downstream_id__.unwrap_or_default(),
11679                })
11680            }
11681        }
11682        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
11683    }
11684}
11685impl serde::Serialize for StreamFsFetch {
11686    #[allow(deprecated)]
11687    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11688    where
11689        S: serde::Serializer,
11690    {
11691        use serde::ser::SerializeStruct;
11692        let mut len = 0;
11693        if self.source_id != 0 {
11694            len += 1;
11695        }
11696        if self.state_table.is_some() {
11697            len += 1;
11698        }
11699        if self.row_id_index.is_some() {
11700            len += 1;
11701        }
11702        if !self.columns.is_empty() {
11703            len += 1;
11704        }
11705        if !self.with_properties.is_empty() {
11706            len += 1;
11707        }
11708        if self.info.is_some() {
11709            len += 1;
11710        }
11711        if !self.source_name.is_empty() {
11712            len += 1;
11713        }
11714        if self.rate_limit.is_some() {
11715            len += 1;
11716        }
11717        if !self.secret_refs.is_empty() {
11718            len += 1;
11719        }
11720        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11721        if self.source_id != 0 {
11722            struct_ser.serialize_field("sourceId", &self.source_id)?;
11723        }
11724        if let Some(v) = self.state_table.as_ref() {
11725            struct_ser.serialize_field("stateTable", v)?;
11726        }
11727        if let Some(v) = self.row_id_index.as_ref() {
11728            struct_ser.serialize_field("rowIdIndex", v)?;
11729        }
11730        if !self.columns.is_empty() {
11731            struct_ser.serialize_field("columns", &self.columns)?;
11732        }
11733        if !self.with_properties.is_empty() {
11734            struct_ser.serialize_field("withProperties", &self.with_properties)?;
11735        }
11736        if let Some(v) = self.info.as_ref() {
11737            struct_ser.serialize_field("info", v)?;
11738        }
11739        if !self.source_name.is_empty() {
11740            struct_ser.serialize_field("sourceName", &self.source_name)?;
11741        }
11742        if let Some(v) = self.rate_limit.as_ref() {
11743            struct_ser.serialize_field("rateLimit", v)?;
11744        }
11745        if !self.secret_refs.is_empty() {
11746            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11747        }
11748        struct_ser.end()
11749    }
11750}
11751impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11752    #[allow(deprecated)]
11753    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11754    where
11755        D: serde::Deserializer<'de>,
11756    {
11757        const FIELDS: &[&str] = &[
11758            "source_id",
11759            "sourceId",
11760            "state_table",
11761            "stateTable",
11762            "row_id_index",
11763            "rowIdIndex",
11764            "columns",
11765            "with_properties",
11766            "withProperties",
11767            "info",
11768            "source_name",
11769            "sourceName",
11770            "rate_limit",
11771            "rateLimit",
11772            "secret_refs",
11773            "secretRefs",
11774        ];
11775
11776        #[allow(clippy::enum_variant_names)]
11777        enum GeneratedField {
11778            SourceId,
11779            StateTable,
11780            RowIdIndex,
11781            Columns,
11782            WithProperties,
11783            Info,
11784            SourceName,
11785            RateLimit,
11786            SecretRefs,
11787        }
11788        impl<'de> serde::Deserialize<'de> for GeneratedField {
11789            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11790            where
11791                D: serde::Deserializer<'de>,
11792            {
11793                struct GeneratedVisitor;
11794
11795                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11796                    type Value = GeneratedField;
11797
11798                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11799                        write!(formatter, "expected one of: {:?}", &FIELDS)
11800                    }
11801
11802                    #[allow(unused_variables)]
11803                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11804                    where
11805                        E: serde::de::Error,
11806                    {
11807                        match value {
11808                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11809                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11810                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11811                            "columns" => Ok(GeneratedField::Columns),
11812                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11813                            "info" => Ok(GeneratedField::Info),
11814                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11815                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11816                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11817                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11818                        }
11819                    }
11820                }
11821                deserializer.deserialize_identifier(GeneratedVisitor)
11822            }
11823        }
11824        struct GeneratedVisitor;
11825        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11826            type Value = StreamFsFetch;
11827
11828            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11829                formatter.write_str("struct stream_plan.StreamFsFetch")
11830            }
11831
11832            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11833                where
11834                    V: serde::de::MapAccess<'de>,
11835            {
11836                let mut source_id__ = None;
11837                let mut state_table__ = None;
11838                let mut row_id_index__ = None;
11839                let mut columns__ = None;
11840                let mut with_properties__ = None;
11841                let mut info__ = None;
11842                let mut source_name__ = None;
11843                let mut rate_limit__ = None;
11844                let mut secret_refs__ = None;
11845                while let Some(k) = map_.next_key()? {
11846                    match k {
11847                        GeneratedField::SourceId => {
11848                            if source_id__.is_some() {
11849                                return Err(serde::de::Error::duplicate_field("sourceId"));
11850                            }
11851                            source_id__ = 
11852                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11853                            ;
11854                        }
11855                        GeneratedField::StateTable => {
11856                            if state_table__.is_some() {
11857                                return Err(serde::de::Error::duplicate_field("stateTable"));
11858                            }
11859                            state_table__ = map_.next_value()?;
11860                        }
11861                        GeneratedField::RowIdIndex => {
11862                            if row_id_index__.is_some() {
11863                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11864                            }
11865                            row_id_index__ = 
11866                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11867                            ;
11868                        }
11869                        GeneratedField::Columns => {
11870                            if columns__.is_some() {
11871                                return Err(serde::de::Error::duplicate_field("columns"));
11872                            }
11873                            columns__ = Some(map_.next_value()?);
11874                        }
11875                        GeneratedField::WithProperties => {
11876                            if with_properties__.is_some() {
11877                                return Err(serde::de::Error::duplicate_field("withProperties"));
11878                            }
11879                            with_properties__ = Some(
11880                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11881                            );
11882                        }
11883                        GeneratedField::Info => {
11884                            if info__.is_some() {
11885                                return Err(serde::de::Error::duplicate_field("info"));
11886                            }
11887                            info__ = map_.next_value()?;
11888                        }
11889                        GeneratedField::SourceName => {
11890                            if source_name__.is_some() {
11891                                return Err(serde::de::Error::duplicate_field("sourceName"));
11892                            }
11893                            source_name__ = Some(map_.next_value()?);
11894                        }
11895                        GeneratedField::RateLimit => {
11896                            if rate_limit__.is_some() {
11897                                return Err(serde::de::Error::duplicate_field("rateLimit"));
11898                            }
11899                            rate_limit__ = 
11900                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11901                            ;
11902                        }
11903                        GeneratedField::SecretRefs => {
11904                            if secret_refs__.is_some() {
11905                                return Err(serde::de::Error::duplicate_field("secretRefs"));
11906                            }
11907                            secret_refs__ = Some(
11908                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11909                            );
11910                        }
11911                    }
11912                }
11913                Ok(StreamFsFetch {
11914                    source_id: source_id__.unwrap_or_default(),
11915                    state_table: state_table__,
11916                    row_id_index: row_id_index__,
11917                    columns: columns__.unwrap_or_default(),
11918                    with_properties: with_properties__.unwrap_or_default(),
11919                    info: info__,
11920                    source_name: source_name__.unwrap_or_default(),
11921                    rate_limit: rate_limit__,
11922                    secret_refs: secret_refs__.unwrap_or_default(),
11923                })
11924            }
11925        }
11926        deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11927    }
11928}
11929impl serde::Serialize for StreamFsFetchNode {
11930    #[allow(deprecated)]
11931    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11932    where
11933        S: serde::Serializer,
11934    {
11935        use serde::ser::SerializeStruct;
11936        let mut len = 0;
11937        if self.node_inner.is_some() {
11938            len += 1;
11939        }
11940        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11941        if let Some(v) = self.node_inner.as_ref() {
11942            struct_ser.serialize_field("nodeInner", v)?;
11943        }
11944        struct_ser.end()
11945    }
11946}
11947impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11948    #[allow(deprecated)]
11949    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11950    where
11951        D: serde::Deserializer<'de>,
11952    {
11953        const FIELDS: &[&str] = &[
11954            "node_inner",
11955            "nodeInner",
11956        ];
11957
11958        #[allow(clippy::enum_variant_names)]
11959        enum GeneratedField {
11960            NodeInner,
11961        }
11962        impl<'de> serde::Deserialize<'de> for GeneratedField {
11963            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11964            where
11965                D: serde::Deserializer<'de>,
11966            {
11967                struct GeneratedVisitor;
11968
11969                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11970                    type Value = GeneratedField;
11971
11972                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11973                        write!(formatter, "expected one of: {:?}", &FIELDS)
11974                    }
11975
11976                    #[allow(unused_variables)]
11977                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11978                    where
11979                        E: serde::de::Error,
11980                    {
11981                        match value {
11982                            "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11983                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11984                        }
11985                    }
11986                }
11987                deserializer.deserialize_identifier(GeneratedVisitor)
11988            }
11989        }
11990        struct GeneratedVisitor;
11991        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11992            type Value = StreamFsFetchNode;
11993
11994            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11995                formatter.write_str("struct stream_plan.StreamFsFetchNode")
11996            }
11997
11998            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11999                where
12000                    V: serde::de::MapAccess<'de>,
12001            {
12002                let mut node_inner__ = None;
12003                while let Some(k) = map_.next_key()? {
12004                    match k {
12005                        GeneratedField::NodeInner => {
12006                            if node_inner__.is_some() {
12007                                return Err(serde::de::Error::duplicate_field("nodeInner"));
12008                            }
12009                            node_inner__ = map_.next_value()?;
12010                        }
12011                    }
12012                }
12013                Ok(StreamFsFetchNode {
12014                    node_inner: node_inner__,
12015                })
12016            }
12017        }
12018        deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
12019    }
12020}
12021impl serde::Serialize for StreamMessage {
12022    #[allow(deprecated)]
12023    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12024    where
12025        S: serde::Serializer,
12026    {
12027        use serde::ser::SerializeStruct;
12028        let mut len = 0;
12029        if self.stream_message.is_some() {
12030            len += 1;
12031        }
12032        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
12033        if let Some(v) = self.stream_message.as_ref() {
12034            match v {
12035                stream_message::StreamMessage::StreamChunk(v) => {
12036                    struct_ser.serialize_field("streamChunk", v)?;
12037                }
12038                stream_message::StreamMessage::Barrier(v) => {
12039                    struct_ser.serialize_field("barrier", v)?;
12040                }
12041                stream_message::StreamMessage::Watermark(v) => {
12042                    struct_ser.serialize_field("watermark", v)?;
12043                }
12044            }
12045        }
12046        struct_ser.end()
12047    }
12048}
12049impl<'de> serde::Deserialize<'de> for StreamMessage {
12050    #[allow(deprecated)]
12051    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12052    where
12053        D: serde::Deserializer<'de>,
12054    {
12055        const FIELDS: &[&str] = &[
12056            "stream_chunk",
12057            "streamChunk",
12058            "barrier",
12059            "watermark",
12060        ];
12061
12062        #[allow(clippy::enum_variant_names)]
12063        enum GeneratedField {
12064            StreamChunk,
12065            Barrier,
12066            Watermark,
12067        }
12068        impl<'de> serde::Deserialize<'de> for GeneratedField {
12069            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12070            where
12071                D: serde::Deserializer<'de>,
12072            {
12073                struct GeneratedVisitor;
12074
12075                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12076                    type Value = GeneratedField;
12077
12078                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12079                        write!(formatter, "expected one of: {:?}", &FIELDS)
12080                    }
12081
12082                    #[allow(unused_variables)]
12083                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12084                    where
12085                        E: serde::de::Error,
12086                    {
12087                        match value {
12088                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12089                            "barrier" => Ok(GeneratedField::Barrier),
12090                            "watermark" => Ok(GeneratedField::Watermark),
12091                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12092                        }
12093                    }
12094                }
12095                deserializer.deserialize_identifier(GeneratedVisitor)
12096            }
12097        }
12098        struct GeneratedVisitor;
12099        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12100            type Value = StreamMessage;
12101
12102            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12103                formatter.write_str("struct stream_plan.StreamMessage")
12104            }
12105
12106            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
12107                where
12108                    V: serde::de::MapAccess<'de>,
12109            {
12110                let mut stream_message__ = None;
12111                while let Some(k) = map_.next_key()? {
12112                    match k {
12113                        GeneratedField::StreamChunk => {
12114                            if stream_message__.is_some() {
12115                                return Err(serde::de::Error::duplicate_field("streamChunk"));
12116                            }
12117                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
12118;
12119                        }
12120                        GeneratedField::Barrier => {
12121                            if stream_message__.is_some() {
12122                                return Err(serde::de::Error::duplicate_field("barrier"));
12123                            }
12124                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
12125;
12126                        }
12127                        GeneratedField::Watermark => {
12128                            if stream_message__.is_some() {
12129                                return Err(serde::de::Error::duplicate_field("watermark"));
12130                            }
12131                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
12132;
12133                        }
12134                    }
12135                }
12136                Ok(StreamMessage {
12137                    stream_message: stream_message__,
12138                })
12139            }
12140        }
12141        deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
12142    }
12143}
12144impl serde::Serialize for StreamMessageBatch {
12145    #[allow(deprecated)]
12146    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12147    where
12148        S: serde::Serializer,
12149    {
12150        use serde::ser::SerializeStruct;
12151        let mut len = 0;
12152        if self.stream_message_batch.is_some() {
12153            len += 1;
12154        }
12155        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12156        if let Some(v) = self.stream_message_batch.as_ref() {
12157            match v {
12158                stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12159                    struct_ser.serialize_field("streamChunk", v)?;
12160                }
12161                stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12162                    struct_ser.serialize_field("barrierBatch", v)?;
12163                }
12164                stream_message_batch::StreamMessageBatch::Watermark(v) => {
12165                    struct_ser.serialize_field("watermark", v)?;
12166                }
12167            }
12168        }
12169        struct_ser.end()
12170    }
12171}
12172impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12173    #[allow(deprecated)]
12174    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12175    where
12176        D: serde::Deserializer<'de>,
12177    {
12178        const FIELDS: &[&str] = &[
12179            "stream_chunk",
12180            "streamChunk",
12181            "barrier_batch",
12182            "barrierBatch",
12183            "watermark",
12184        ];
12185
12186        #[allow(clippy::enum_variant_names)]
12187        enum GeneratedField {
12188            StreamChunk,
12189            BarrierBatch,
12190            Watermark,
12191        }
12192        impl<'de> serde::Deserialize<'de> for GeneratedField {
12193            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12194            where
12195                D: serde::Deserializer<'de>,
12196            {
12197                struct GeneratedVisitor;
12198
12199                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12200                    type Value = GeneratedField;
12201
12202                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12203                        write!(formatter, "expected one of: {:?}", &FIELDS)
12204                    }
12205
12206                    #[allow(unused_variables)]
12207                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12208                    where
12209                        E: serde::de::Error,
12210                    {
12211                        match value {
12212                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12213                            "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12214                            "watermark" => Ok(GeneratedField::Watermark),
12215                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12216                        }
12217                    }
12218                }
12219                deserializer.deserialize_identifier(GeneratedVisitor)
12220            }
12221        }
12222        struct GeneratedVisitor;
12223        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12224            type Value = StreamMessageBatch;
12225
12226            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12227                formatter.write_str("struct stream_plan.StreamMessageBatch")
12228            }
12229
12230            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12231                where
12232                    V: serde::de::MapAccess<'de>,
12233            {
12234                let mut stream_message_batch__ = None;
12235                while let Some(k) = map_.next_key()? {
12236                    match k {
12237                        GeneratedField::StreamChunk => {
12238                            if stream_message_batch__.is_some() {
12239                                return Err(serde::de::Error::duplicate_field("streamChunk"));
12240                            }
12241                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12242;
12243                        }
12244                        GeneratedField::BarrierBatch => {
12245                            if stream_message_batch__.is_some() {
12246                                return Err(serde::de::Error::duplicate_field("barrierBatch"));
12247                            }
12248                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12249;
12250                        }
12251                        GeneratedField::Watermark => {
12252                            if stream_message_batch__.is_some() {
12253                                return Err(serde::de::Error::duplicate_field("watermark"));
12254                            }
12255                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12256;
12257                        }
12258                    }
12259                }
12260                Ok(StreamMessageBatch {
12261                    stream_message_batch: stream_message_batch__,
12262                })
12263            }
12264        }
12265        deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12266    }
12267}
12268impl serde::Serialize for stream_message_batch::BarrierBatch {
12269    #[allow(deprecated)]
12270    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12271    where
12272        S: serde::Serializer,
12273    {
12274        use serde::ser::SerializeStruct;
12275        let mut len = 0;
12276        if !self.barriers.is_empty() {
12277            len += 1;
12278        }
12279        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12280        if !self.barriers.is_empty() {
12281            struct_ser.serialize_field("barriers", &self.barriers)?;
12282        }
12283        struct_ser.end()
12284    }
12285}
12286impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12287    #[allow(deprecated)]
12288    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12289    where
12290        D: serde::Deserializer<'de>,
12291    {
12292        const FIELDS: &[&str] = &[
12293            "barriers",
12294        ];
12295
12296        #[allow(clippy::enum_variant_names)]
12297        enum GeneratedField {
12298            Barriers,
12299        }
12300        impl<'de> serde::Deserialize<'de> for GeneratedField {
12301            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12302            where
12303                D: serde::Deserializer<'de>,
12304            {
12305                struct GeneratedVisitor;
12306
12307                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12308                    type Value = GeneratedField;
12309
12310                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12311                        write!(formatter, "expected one of: {:?}", &FIELDS)
12312                    }
12313
12314                    #[allow(unused_variables)]
12315                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12316                    where
12317                        E: serde::de::Error,
12318                    {
12319                        match value {
12320                            "barriers" => Ok(GeneratedField::Barriers),
12321                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12322                        }
12323                    }
12324                }
12325                deserializer.deserialize_identifier(GeneratedVisitor)
12326            }
12327        }
12328        struct GeneratedVisitor;
12329        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12330            type Value = stream_message_batch::BarrierBatch;
12331
12332            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12333                formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12334            }
12335
12336            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12337                where
12338                    V: serde::de::MapAccess<'de>,
12339            {
12340                let mut barriers__ = None;
12341                while let Some(k) = map_.next_key()? {
12342                    match k {
12343                        GeneratedField::Barriers => {
12344                            if barriers__.is_some() {
12345                                return Err(serde::de::Error::duplicate_field("barriers"));
12346                            }
12347                            barriers__ = Some(map_.next_value()?);
12348                        }
12349                    }
12350                }
12351                Ok(stream_message_batch::BarrierBatch {
12352                    barriers: barriers__.unwrap_or_default(),
12353                })
12354            }
12355        }
12356        deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12357    }
12358}
12359impl serde::Serialize for StreamNode {
12360    #[allow(deprecated)]
12361    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12362    where
12363        S: serde::Serializer,
12364    {
12365        use serde::ser::SerializeStruct;
12366        let mut len = 0;
12367        if self.operator_id != 0 {
12368            len += 1;
12369        }
12370        if !self.input.is_empty() {
12371            len += 1;
12372        }
12373        if !self.stream_key.is_empty() {
12374            len += 1;
12375        }
12376        if self.stream_kind != 0 {
12377            len += 1;
12378        }
12379        if !self.identity.is_empty() {
12380            len += 1;
12381        }
12382        if !self.fields.is_empty() {
12383            len += 1;
12384        }
12385        if self.node_body.is_some() {
12386            len += 1;
12387        }
12388        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12389        if self.operator_id != 0 {
12390            #[allow(clippy::needless_borrow)]
12391            #[allow(clippy::needless_borrows_for_generic_args)]
12392            struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12393        }
12394        if !self.input.is_empty() {
12395            struct_ser.serialize_field("input", &self.input)?;
12396        }
12397        if !self.stream_key.is_empty() {
12398            struct_ser.serialize_field("streamKey", &self.stream_key)?;
12399        }
12400        if self.stream_kind != 0 {
12401            let v = stream_node::StreamKind::try_from(self.stream_kind)
12402                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12403            struct_ser.serialize_field("streamKind", &v)?;
12404        }
12405        if !self.identity.is_empty() {
12406            struct_ser.serialize_field("identity", &self.identity)?;
12407        }
12408        if !self.fields.is_empty() {
12409            struct_ser.serialize_field("fields", &self.fields)?;
12410        }
12411        if let Some(v) = self.node_body.as_ref() {
12412            match v {
12413                stream_node::NodeBody::Source(v) => {
12414                    struct_ser.serialize_field("source", v)?;
12415                }
12416                stream_node::NodeBody::Project(v) => {
12417                    struct_ser.serialize_field("project", v)?;
12418                }
12419                stream_node::NodeBody::Filter(v) => {
12420                    struct_ser.serialize_field("filter", v)?;
12421                }
12422                stream_node::NodeBody::Materialize(v) => {
12423                    struct_ser.serialize_field("materialize", v)?;
12424                }
12425                stream_node::NodeBody::StatelessSimpleAgg(v) => {
12426                    struct_ser.serialize_field("statelessSimpleAgg", v)?;
12427                }
12428                stream_node::NodeBody::SimpleAgg(v) => {
12429                    struct_ser.serialize_field("simpleAgg", v)?;
12430                }
12431                stream_node::NodeBody::HashAgg(v) => {
12432                    struct_ser.serialize_field("hashAgg", v)?;
12433                }
12434                stream_node::NodeBody::AppendOnlyTopN(v) => {
12435                    struct_ser.serialize_field("appendOnlyTopN", v)?;
12436                }
12437                stream_node::NodeBody::HashJoin(v) => {
12438                    struct_ser.serialize_field("hashJoin", v)?;
12439                }
12440                stream_node::NodeBody::TopN(v) => {
12441                    struct_ser.serialize_field("topN", v)?;
12442                }
12443                stream_node::NodeBody::HopWindow(v) => {
12444                    struct_ser.serialize_field("hopWindow", v)?;
12445                }
12446                stream_node::NodeBody::Merge(v) => {
12447                    struct_ser.serialize_field("merge", v)?;
12448                }
12449                stream_node::NodeBody::Exchange(v) => {
12450                    struct_ser.serialize_field("exchange", v)?;
12451                }
12452                stream_node::NodeBody::StreamScan(v) => {
12453                    struct_ser.serialize_field("streamScan", v)?;
12454                }
12455                stream_node::NodeBody::BatchPlan(v) => {
12456                    struct_ser.serialize_field("batchPlan", v)?;
12457                }
12458                stream_node::NodeBody::Lookup(v) => {
12459                    struct_ser.serialize_field("lookup", v)?;
12460                }
12461                stream_node::NodeBody::Arrange(v) => {
12462                    struct_ser.serialize_field("arrange", v)?;
12463                }
12464                stream_node::NodeBody::LookupUnion(v) => {
12465                    struct_ser.serialize_field("lookupUnion", v)?;
12466                }
12467                stream_node::NodeBody::Union(v) => {
12468                    struct_ser.serialize_field("union", v)?;
12469                }
12470                stream_node::NodeBody::DeltaIndexJoin(v) => {
12471                    struct_ser.serialize_field("deltaIndexJoin", v)?;
12472                }
12473                stream_node::NodeBody::Sink(v) => {
12474                    struct_ser.serialize_field("sink", v)?;
12475                }
12476                stream_node::NodeBody::Expand(v) => {
12477                    struct_ser.serialize_field("expand", v)?;
12478                }
12479                stream_node::NodeBody::DynamicFilter(v) => {
12480                    struct_ser.serialize_field("dynamicFilter", v)?;
12481                }
12482                stream_node::NodeBody::ProjectSet(v) => {
12483                    struct_ser.serialize_field("projectSet", v)?;
12484                }
12485                stream_node::NodeBody::GroupTopN(v) => {
12486                    struct_ser.serialize_field("groupTopN", v)?;
12487                }
12488                stream_node::NodeBody::Sort(v) => {
12489                    struct_ser.serialize_field("sort", v)?;
12490                }
12491                stream_node::NodeBody::WatermarkFilter(v) => {
12492                    struct_ser.serialize_field("watermarkFilter", v)?;
12493                }
12494                stream_node::NodeBody::Dml(v) => {
12495                    struct_ser.serialize_field("dml", v)?;
12496                }
12497                stream_node::NodeBody::RowIdGen(v) => {
12498                    struct_ser.serialize_field("rowIdGen", v)?;
12499                }
12500                stream_node::NodeBody::Now(v) => {
12501                    struct_ser.serialize_field("now", v)?;
12502                }
12503                stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
12504                    struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
12505                }
12506                stream_node::NodeBody::TemporalJoin(v) => {
12507                    struct_ser.serialize_field("temporalJoin", v)?;
12508                }
12509                stream_node::NodeBody::BarrierRecv(v) => {
12510                    struct_ser.serialize_field("barrierRecv", v)?;
12511                }
12512                stream_node::NodeBody::Values(v) => {
12513                    struct_ser.serialize_field("values", v)?;
12514                }
12515                stream_node::NodeBody::AppendOnlyDedup(v) => {
12516                    struct_ser.serialize_field("appendOnlyDedup", v)?;
12517                }
12518                stream_node::NodeBody::NoOp(v) => {
12519                    struct_ser.serialize_field("noOp", v)?;
12520                }
12521                stream_node::NodeBody::EowcOverWindow(v) => {
12522                    struct_ser.serialize_field("eowcOverWindow", v)?;
12523                }
12524                stream_node::NodeBody::OverWindow(v) => {
12525                    struct_ser.serialize_field("overWindow", v)?;
12526                }
12527                stream_node::NodeBody::StreamFsFetch(v) => {
12528                    struct_ser.serialize_field("streamFsFetch", v)?;
12529                }
12530                stream_node::NodeBody::StreamCdcScan(v) => {
12531                    struct_ser.serialize_field("streamCdcScan", v)?;
12532                }
12533                stream_node::NodeBody::CdcFilter(v) => {
12534                    struct_ser.serialize_field("cdcFilter", v)?;
12535                }
12536                stream_node::NodeBody::SourceBackfill(v) => {
12537                    struct_ser.serialize_field("sourceBackfill", v)?;
12538                }
12539                stream_node::NodeBody::Changelog(v) => {
12540                    struct_ser.serialize_field("changelog", v)?;
12541                }
12542                stream_node::NodeBody::LocalApproxPercentile(v) => {
12543                    struct_ser.serialize_field("localApproxPercentile", v)?;
12544                }
12545                stream_node::NodeBody::GlobalApproxPercentile(v) => {
12546                    struct_ser.serialize_field("globalApproxPercentile", v)?;
12547                }
12548                stream_node::NodeBody::RowMerge(v) => {
12549                    struct_ser.serialize_field("rowMerge", v)?;
12550                }
12551                stream_node::NodeBody::AsOfJoin(v) => {
12552                    struct_ser.serialize_field("asOfJoin", v)?;
12553                }
12554                stream_node::NodeBody::SyncLogStore(v) => {
12555                    struct_ser.serialize_field("syncLogStore", v)?;
12556                }
12557                stream_node::NodeBody::MaterializedExprs(v) => {
12558                    struct_ser.serialize_field("materializedExprs", v)?;
12559                }
12560                stream_node::NodeBody::VectorIndexWrite(v) => {
12561                    struct_ser.serialize_field("vectorIndexWrite", v)?;
12562                }
12563                stream_node::NodeBody::UpstreamSinkUnion(v) => {
12564                    struct_ser.serialize_field("upstreamSinkUnion", v)?;
12565                }
12566                stream_node::NodeBody::LocalityProvider(v) => {
12567                    struct_ser.serialize_field("localityProvider", v)?;
12568                }
12569            }
12570        }
12571        struct_ser.end()
12572    }
12573}
12574impl<'de> serde::Deserialize<'de> for StreamNode {
12575    #[allow(deprecated)]
12576    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12577    where
12578        D: serde::Deserializer<'de>,
12579    {
12580        const FIELDS: &[&str] = &[
12581            "operator_id",
12582            "operatorId",
12583            "input",
12584            "stream_key",
12585            "streamKey",
12586            "stream_kind",
12587            "streamKind",
12588            "identity",
12589            "fields",
12590            "source",
12591            "project",
12592            "filter",
12593            "materialize",
12594            "stateless_simple_agg",
12595            "statelessSimpleAgg",
12596            "simple_agg",
12597            "simpleAgg",
12598            "hash_agg",
12599            "hashAgg",
12600            "append_only_top_n",
12601            "appendOnlyTopN",
12602            "hash_join",
12603            "hashJoin",
12604            "top_n",
12605            "topN",
12606            "hop_window",
12607            "hopWindow",
12608            "merge",
12609            "exchange",
12610            "stream_scan",
12611            "streamScan",
12612            "batch_plan",
12613            "batchPlan",
12614            "lookup",
12615            "arrange",
12616            "lookup_union",
12617            "lookupUnion",
12618            "union",
12619            "delta_index_join",
12620            "deltaIndexJoin",
12621            "sink",
12622            "expand",
12623            "dynamic_filter",
12624            "dynamicFilter",
12625            "project_set",
12626            "projectSet",
12627            "group_top_n",
12628            "groupTopN",
12629            "sort",
12630            "watermark_filter",
12631            "watermarkFilter",
12632            "dml",
12633            "row_id_gen",
12634            "rowIdGen",
12635            "now",
12636            "append_only_group_top_n",
12637            "appendOnlyGroupTopN",
12638            "temporal_join",
12639            "temporalJoin",
12640            "barrier_recv",
12641            "barrierRecv",
12642            "values",
12643            "append_only_dedup",
12644            "appendOnlyDedup",
12645            "no_op",
12646            "noOp",
12647            "eowc_over_window",
12648            "eowcOverWindow",
12649            "over_window",
12650            "overWindow",
12651            "stream_fs_fetch",
12652            "streamFsFetch",
12653            "stream_cdc_scan",
12654            "streamCdcScan",
12655            "cdc_filter",
12656            "cdcFilter",
12657            "source_backfill",
12658            "sourceBackfill",
12659            "changelog",
12660            "local_approx_percentile",
12661            "localApproxPercentile",
12662            "global_approx_percentile",
12663            "globalApproxPercentile",
12664            "row_merge",
12665            "rowMerge",
12666            "as_of_join",
12667            "asOfJoin",
12668            "sync_log_store",
12669            "syncLogStore",
12670            "materialized_exprs",
12671            "materializedExprs",
12672            "vector_index_write",
12673            "vectorIndexWrite",
12674            "upstream_sink_union",
12675            "upstreamSinkUnion",
12676            "locality_provider",
12677            "localityProvider",
12678        ];
12679
12680        #[allow(clippy::enum_variant_names)]
12681        enum GeneratedField {
12682            OperatorId,
12683            Input,
12684            StreamKey,
12685            StreamKind,
12686            Identity,
12687            Fields,
12688            Source,
12689            Project,
12690            Filter,
12691            Materialize,
12692            StatelessSimpleAgg,
12693            SimpleAgg,
12694            HashAgg,
12695            AppendOnlyTopN,
12696            HashJoin,
12697            TopN,
12698            HopWindow,
12699            Merge,
12700            Exchange,
12701            StreamScan,
12702            BatchPlan,
12703            Lookup,
12704            Arrange,
12705            LookupUnion,
12706            Union,
12707            DeltaIndexJoin,
12708            Sink,
12709            Expand,
12710            DynamicFilter,
12711            ProjectSet,
12712            GroupTopN,
12713            Sort,
12714            WatermarkFilter,
12715            Dml,
12716            RowIdGen,
12717            Now,
12718            AppendOnlyGroupTopN,
12719            TemporalJoin,
12720            BarrierRecv,
12721            Values,
12722            AppendOnlyDedup,
12723            NoOp,
12724            EowcOverWindow,
12725            OverWindow,
12726            StreamFsFetch,
12727            StreamCdcScan,
12728            CdcFilter,
12729            SourceBackfill,
12730            Changelog,
12731            LocalApproxPercentile,
12732            GlobalApproxPercentile,
12733            RowMerge,
12734            AsOfJoin,
12735            SyncLogStore,
12736            MaterializedExprs,
12737            VectorIndexWrite,
12738            UpstreamSinkUnion,
12739            LocalityProvider,
12740        }
12741        impl<'de> serde::Deserialize<'de> for GeneratedField {
12742            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12743            where
12744                D: serde::Deserializer<'de>,
12745            {
12746                struct GeneratedVisitor;
12747
12748                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12749                    type Value = GeneratedField;
12750
12751                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12752                        write!(formatter, "expected one of: {:?}", &FIELDS)
12753                    }
12754
12755                    #[allow(unused_variables)]
12756                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12757                    where
12758                        E: serde::de::Error,
12759                    {
12760                        match value {
12761                            "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12762                            "input" => Ok(GeneratedField::Input),
12763                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12764                            "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
12765                            "identity" => Ok(GeneratedField::Identity),
12766                            "fields" => Ok(GeneratedField::Fields),
12767                            "source" => Ok(GeneratedField::Source),
12768                            "project" => Ok(GeneratedField::Project),
12769                            "filter" => Ok(GeneratedField::Filter),
12770                            "materialize" => Ok(GeneratedField::Materialize),
12771                            "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12772                            "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12773                            "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12774                            "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12775                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12776                            "topN" | "top_n" => Ok(GeneratedField::TopN),
12777                            "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12778                            "merge" => Ok(GeneratedField::Merge),
12779                            "exchange" => Ok(GeneratedField::Exchange),
12780                            "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12781                            "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12782                            "lookup" => Ok(GeneratedField::Lookup),
12783                            "arrange" => Ok(GeneratedField::Arrange),
12784                            "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12785                            "union" => Ok(GeneratedField::Union),
12786                            "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12787                            "sink" => Ok(GeneratedField::Sink),
12788                            "expand" => Ok(GeneratedField::Expand),
12789                            "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12790                            "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12791                            "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12792                            "sort" => Ok(GeneratedField::Sort),
12793                            "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12794                            "dml" => Ok(GeneratedField::Dml),
12795                            "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12796                            "now" => Ok(GeneratedField::Now),
12797                            "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12798                            "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12799                            "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12800                            "values" => Ok(GeneratedField::Values),
12801                            "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12802                            "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12803                            "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12804                            "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12805                            "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12806                            "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12807                            "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12808                            "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12809                            "changelog" => Ok(GeneratedField::Changelog),
12810                            "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12811                            "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12812                            "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12813                            "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12814                            "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12815                            "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12816                            "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
12817                            "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
12818                            "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
12819                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12820                        }
12821                    }
12822                }
12823                deserializer.deserialize_identifier(GeneratedVisitor)
12824            }
12825        }
12826        struct GeneratedVisitor;
12827        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12828            type Value = StreamNode;
12829
12830            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12831                formatter.write_str("struct stream_plan.StreamNode")
12832            }
12833
12834            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12835                where
12836                    V: serde::de::MapAccess<'de>,
12837            {
12838                let mut operator_id__ = None;
12839                let mut input__ = None;
12840                let mut stream_key__ = None;
12841                let mut stream_kind__ = None;
12842                let mut identity__ = None;
12843                let mut fields__ = None;
12844                let mut node_body__ = None;
12845                while let Some(k) = map_.next_key()? {
12846                    match k {
12847                        GeneratedField::OperatorId => {
12848                            if operator_id__.is_some() {
12849                                return Err(serde::de::Error::duplicate_field("operatorId"));
12850                            }
12851                            operator_id__ = 
12852                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12853                            ;
12854                        }
12855                        GeneratedField::Input => {
12856                            if input__.is_some() {
12857                                return Err(serde::de::Error::duplicate_field("input"));
12858                            }
12859                            input__ = Some(map_.next_value()?);
12860                        }
12861                        GeneratedField::StreamKey => {
12862                            if stream_key__.is_some() {
12863                                return Err(serde::de::Error::duplicate_field("streamKey"));
12864                            }
12865                            stream_key__ = 
12866                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12867                                    .into_iter().map(|x| x.0).collect())
12868                            ;
12869                        }
12870                        GeneratedField::StreamKind => {
12871                            if stream_kind__.is_some() {
12872                                return Err(serde::de::Error::duplicate_field("streamKind"));
12873                            }
12874                            stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
12875                        }
12876                        GeneratedField::Identity => {
12877                            if identity__.is_some() {
12878                                return Err(serde::de::Error::duplicate_field("identity"));
12879                            }
12880                            identity__ = Some(map_.next_value()?);
12881                        }
12882                        GeneratedField::Fields => {
12883                            if fields__.is_some() {
12884                                return Err(serde::de::Error::duplicate_field("fields"));
12885                            }
12886                            fields__ = Some(map_.next_value()?);
12887                        }
12888                        GeneratedField::Source => {
12889                            if node_body__.is_some() {
12890                                return Err(serde::de::Error::duplicate_field("source"));
12891                            }
12892                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12893;
12894                        }
12895                        GeneratedField::Project => {
12896                            if node_body__.is_some() {
12897                                return Err(serde::de::Error::duplicate_field("project"));
12898                            }
12899                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12900;
12901                        }
12902                        GeneratedField::Filter => {
12903                            if node_body__.is_some() {
12904                                return Err(serde::de::Error::duplicate_field("filter"));
12905                            }
12906                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12907;
12908                        }
12909                        GeneratedField::Materialize => {
12910                            if node_body__.is_some() {
12911                                return Err(serde::de::Error::duplicate_field("materialize"));
12912                            }
12913                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12914;
12915                        }
12916                        GeneratedField::StatelessSimpleAgg => {
12917                            if node_body__.is_some() {
12918                                return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12919                            }
12920                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12921;
12922                        }
12923                        GeneratedField::SimpleAgg => {
12924                            if node_body__.is_some() {
12925                                return Err(serde::de::Error::duplicate_field("simpleAgg"));
12926                            }
12927                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12928;
12929                        }
12930                        GeneratedField::HashAgg => {
12931                            if node_body__.is_some() {
12932                                return Err(serde::de::Error::duplicate_field("hashAgg"));
12933                            }
12934                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12935;
12936                        }
12937                        GeneratedField::AppendOnlyTopN => {
12938                            if node_body__.is_some() {
12939                                return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12940                            }
12941                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12942;
12943                        }
12944                        GeneratedField::HashJoin => {
12945                            if node_body__.is_some() {
12946                                return Err(serde::de::Error::duplicate_field("hashJoin"));
12947                            }
12948                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12949;
12950                        }
12951                        GeneratedField::TopN => {
12952                            if node_body__.is_some() {
12953                                return Err(serde::de::Error::duplicate_field("topN"));
12954                            }
12955                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12956;
12957                        }
12958                        GeneratedField::HopWindow => {
12959                            if node_body__.is_some() {
12960                                return Err(serde::de::Error::duplicate_field("hopWindow"));
12961                            }
12962                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12963;
12964                        }
12965                        GeneratedField::Merge => {
12966                            if node_body__.is_some() {
12967                                return Err(serde::de::Error::duplicate_field("merge"));
12968                            }
12969                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12970;
12971                        }
12972                        GeneratedField::Exchange => {
12973                            if node_body__.is_some() {
12974                                return Err(serde::de::Error::duplicate_field("exchange"));
12975                            }
12976                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12977;
12978                        }
12979                        GeneratedField::StreamScan => {
12980                            if node_body__.is_some() {
12981                                return Err(serde::de::Error::duplicate_field("streamScan"));
12982                            }
12983                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12984;
12985                        }
12986                        GeneratedField::BatchPlan => {
12987                            if node_body__.is_some() {
12988                                return Err(serde::de::Error::duplicate_field("batchPlan"));
12989                            }
12990                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12991;
12992                        }
12993                        GeneratedField::Lookup => {
12994                            if node_body__.is_some() {
12995                                return Err(serde::de::Error::duplicate_field("lookup"));
12996                            }
12997                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12998;
12999                        }
13000                        GeneratedField::Arrange => {
13001                            if node_body__.is_some() {
13002                                return Err(serde::de::Error::duplicate_field("arrange"));
13003                            }
13004                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
13005;
13006                        }
13007                        GeneratedField::LookupUnion => {
13008                            if node_body__.is_some() {
13009                                return Err(serde::de::Error::duplicate_field("lookupUnion"));
13010                            }
13011                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
13012;
13013                        }
13014                        GeneratedField::Union => {
13015                            if node_body__.is_some() {
13016                                return Err(serde::de::Error::duplicate_field("union"));
13017                            }
13018                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
13019;
13020                        }
13021                        GeneratedField::DeltaIndexJoin => {
13022                            if node_body__.is_some() {
13023                                return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
13024                            }
13025                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
13026;
13027                        }
13028                        GeneratedField::Sink => {
13029                            if node_body__.is_some() {
13030                                return Err(serde::de::Error::duplicate_field("sink"));
13031                            }
13032                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
13033;
13034                        }
13035                        GeneratedField::Expand => {
13036                            if node_body__.is_some() {
13037                                return Err(serde::de::Error::duplicate_field("expand"));
13038                            }
13039                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
13040;
13041                        }
13042                        GeneratedField::DynamicFilter => {
13043                            if node_body__.is_some() {
13044                                return Err(serde::de::Error::duplicate_field("dynamicFilter"));
13045                            }
13046                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
13047;
13048                        }
13049                        GeneratedField::ProjectSet => {
13050                            if node_body__.is_some() {
13051                                return Err(serde::de::Error::duplicate_field("projectSet"));
13052                            }
13053                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
13054;
13055                        }
13056                        GeneratedField::GroupTopN => {
13057                            if node_body__.is_some() {
13058                                return Err(serde::de::Error::duplicate_field("groupTopN"));
13059                            }
13060                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
13061;
13062                        }
13063                        GeneratedField::Sort => {
13064                            if node_body__.is_some() {
13065                                return Err(serde::de::Error::duplicate_field("sort"));
13066                            }
13067                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
13068;
13069                        }
13070                        GeneratedField::WatermarkFilter => {
13071                            if node_body__.is_some() {
13072                                return Err(serde::de::Error::duplicate_field("watermarkFilter"));
13073                            }
13074                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
13075;
13076                        }
13077                        GeneratedField::Dml => {
13078                            if node_body__.is_some() {
13079                                return Err(serde::de::Error::duplicate_field("dml"));
13080                            }
13081                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
13082;
13083                        }
13084                        GeneratedField::RowIdGen => {
13085                            if node_body__.is_some() {
13086                                return Err(serde::de::Error::duplicate_field("rowIdGen"));
13087                            }
13088                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
13089;
13090                        }
13091                        GeneratedField::Now => {
13092                            if node_body__.is_some() {
13093                                return Err(serde::de::Error::duplicate_field("now"));
13094                            }
13095                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
13096;
13097                        }
13098                        GeneratedField::AppendOnlyGroupTopN => {
13099                            if node_body__.is_some() {
13100                                return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
13101                            }
13102                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
13103;
13104                        }
13105                        GeneratedField::TemporalJoin => {
13106                            if node_body__.is_some() {
13107                                return Err(serde::de::Error::duplicate_field("temporalJoin"));
13108                            }
13109                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
13110;
13111                        }
13112                        GeneratedField::BarrierRecv => {
13113                            if node_body__.is_some() {
13114                                return Err(serde::de::Error::duplicate_field("barrierRecv"));
13115                            }
13116                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
13117;
13118                        }
13119                        GeneratedField::Values => {
13120                            if node_body__.is_some() {
13121                                return Err(serde::de::Error::duplicate_field("values"));
13122                            }
13123                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
13124;
13125                        }
13126                        GeneratedField::AppendOnlyDedup => {
13127                            if node_body__.is_some() {
13128                                return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
13129                            }
13130                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
13131;
13132                        }
13133                        GeneratedField::NoOp => {
13134                            if node_body__.is_some() {
13135                                return Err(serde::de::Error::duplicate_field("noOp"));
13136                            }
13137                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
13138;
13139                        }
13140                        GeneratedField::EowcOverWindow => {
13141                            if node_body__.is_some() {
13142                                return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
13143                            }
13144                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
13145;
13146                        }
13147                        GeneratedField::OverWindow => {
13148                            if node_body__.is_some() {
13149                                return Err(serde::de::Error::duplicate_field("overWindow"));
13150                            }
13151                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
13152;
13153                        }
13154                        GeneratedField::StreamFsFetch => {
13155                            if node_body__.is_some() {
13156                                return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13157                            }
13158                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13159;
13160                        }
13161                        GeneratedField::StreamCdcScan => {
13162                            if node_body__.is_some() {
13163                                return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13164                            }
13165                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13166;
13167                        }
13168                        GeneratedField::CdcFilter => {
13169                            if node_body__.is_some() {
13170                                return Err(serde::de::Error::duplicate_field("cdcFilter"));
13171                            }
13172                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13173;
13174                        }
13175                        GeneratedField::SourceBackfill => {
13176                            if node_body__.is_some() {
13177                                return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13178                            }
13179                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13180;
13181                        }
13182                        GeneratedField::Changelog => {
13183                            if node_body__.is_some() {
13184                                return Err(serde::de::Error::duplicate_field("changelog"));
13185                            }
13186                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13187;
13188                        }
13189                        GeneratedField::LocalApproxPercentile => {
13190                            if node_body__.is_some() {
13191                                return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13192                            }
13193                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13194;
13195                        }
13196                        GeneratedField::GlobalApproxPercentile => {
13197                            if node_body__.is_some() {
13198                                return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13199                            }
13200                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13201;
13202                        }
13203                        GeneratedField::RowMerge => {
13204                            if node_body__.is_some() {
13205                                return Err(serde::de::Error::duplicate_field("rowMerge"));
13206                            }
13207                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13208;
13209                        }
13210                        GeneratedField::AsOfJoin => {
13211                            if node_body__.is_some() {
13212                                return Err(serde::de::Error::duplicate_field("asOfJoin"));
13213                            }
13214                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13215;
13216                        }
13217                        GeneratedField::SyncLogStore => {
13218                            if node_body__.is_some() {
13219                                return Err(serde::de::Error::duplicate_field("syncLogStore"));
13220                            }
13221                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13222;
13223                        }
13224                        GeneratedField::MaterializedExprs => {
13225                            if node_body__.is_some() {
13226                                return Err(serde::de::Error::duplicate_field("materializedExprs"));
13227                            }
13228                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13229;
13230                        }
13231                        GeneratedField::VectorIndexWrite => {
13232                            if node_body__.is_some() {
13233                                return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13234                            }
13235                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13236;
13237                        }
13238                        GeneratedField::UpstreamSinkUnion => {
13239                            if node_body__.is_some() {
13240                                return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13241                            }
13242                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13243;
13244                        }
13245                        GeneratedField::LocalityProvider => {
13246                            if node_body__.is_some() {
13247                                return Err(serde::de::Error::duplicate_field("localityProvider"));
13248                            }
13249                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
13250;
13251                        }
13252                    }
13253                }
13254                Ok(StreamNode {
13255                    operator_id: operator_id__.unwrap_or_default(),
13256                    input: input__.unwrap_or_default(),
13257                    stream_key: stream_key__.unwrap_or_default(),
13258                    stream_kind: stream_kind__.unwrap_or_default(),
13259                    identity: identity__.unwrap_or_default(),
13260                    fields: fields__.unwrap_or_default(),
13261                    node_body: node_body__,
13262                })
13263            }
13264        }
13265        deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13266    }
13267}
13268impl serde::Serialize for stream_node::StreamKind {
13269    #[allow(deprecated)]
13270    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13271    where
13272        S: serde::Serializer,
13273    {
13274        let variant = match self {
13275            Self::Retract => "STREAM_KIND_RETRACT",
13276            Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13277            Self::Upsert => "STREAM_KIND_UPSERT",
13278        };
13279        serializer.serialize_str(variant)
13280    }
13281}
13282impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13283    #[allow(deprecated)]
13284    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13285    where
13286        D: serde::Deserializer<'de>,
13287    {
13288        const FIELDS: &[&str] = &[
13289            "STREAM_KIND_RETRACT",
13290            "STREAM_KIND_APPEND_ONLY",
13291            "STREAM_KIND_UPSERT",
13292        ];
13293
13294        struct GeneratedVisitor;
13295
13296        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13297            type Value = stream_node::StreamKind;
13298
13299            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13300                write!(formatter, "expected one of: {:?}", &FIELDS)
13301            }
13302
13303            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13304            where
13305                E: serde::de::Error,
13306            {
13307                i32::try_from(v)
13308                    .ok()
13309                    .and_then(|x| x.try_into().ok())
13310                    .ok_or_else(|| {
13311                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13312                    })
13313            }
13314
13315            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13316            where
13317                E: serde::de::Error,
13318            {
13319                i32::try_from(v)
13320                    .ok()
13321                    .and_then(|x| x.try_into().ok())
13322                    .ok_or_else(|| {
13323                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13324                    })
13325            }
13326
13327            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13328            where
13329                E: serde::de::Error,
13330            {
13331                match value {
13332                    "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13333                    "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13334                    "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13335                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13336                }
13337            }
13338        }
13339        deserializer.deserialize_any(GeneratedVisitor)
13340    }
13341}
13342impl serde::Serialize for StreamScanNode {
13343    #[allow(deprecated)]
13344    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13345    where
13346        S: serde::Serializer,
13347    {
13348        use serde::ser::SerializeStruct;
13349        let mut len = 0;
13350        if self.table_id != 0 {
13351            len += 1;
13352        }
13353        if !self.upstream_column_ids.is_empty() {
13354            len += 1;
13355        }
13356        if !self.output_indices.is_empty() {
13357            len += 1;
13358        }
13359        if self.stream_scan_type != 0 {
13360            len += 1;
13361        }
13362        if self.state_table.is_some() {
13363            len += 1;
13364        }
13365        if self.table_desc.is_some() {
13366            len += 1;
13367        }
13368        if self.rate_limit.is_some() {
13369            len += 1;
13370        }
13371        if self.snapshot_read_barrier_interval != 0 {
13372            len += 1;
13373        }
13374        if self.arrangement_table.is_some() {
13375            len += 1;
13376        }
13377        if self.snapshot_backfill_epoch.is_some() {
13378            len += 1;
13379        }
13380        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13381        if self.table_id != 0 {
13382            struct_ser.serialize_field("tableId", &self.table_id)?;
13383        }
13384        if !self.upstream_column_ids.is_empty() {
13385            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13386        }
13387        if !self.output_indices.is_empty() {
13388            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13389        }
13390        if self.stream_scan_type != 0 {
13391            let v = StreamScanType::try_from(self.stream_scan_type)
13392                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13393            struct_ser.serialize_field("streamScanType", &v)?;
13394        }
13395        if let Some(v) = self.state_table.as_ref() {
13396            struct_ser.serialize_field("stateTable", v)?;
13397        }
13398        if let Some(v) = self.table_desc.as_ref() {
13399            struct_ser.serialize_field("tableDesc", v)?;
13400        }
13401        if let Some(v) = self.rate_limit.as_ref() {
13402            struct_ser.serialize_field("rateLimit", v)?;
13403        }
13404        if self.snapshot_read_barrier_interval != 0 {
13405            struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13406        }
13407        if let Some(v) = self.arrangement_table.as_ref() {
13408            struct_ser.serialize_field("arrangementTable", v)?;
13409        }
13410        if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13411            #[allow(clippy::needless_borrow)]
13412            #[allow(clippy::needless_borrows_for_generic_args)]
13413            struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13414        }
13415        struct_ser.end()
13416    }
13417}
13418impl<'de> serde::Deserialize<'de> for StreamScanNode {
13419    #[allow(deprecated)]
13420    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13421    where
13422        D: serde::Deserializer<'de>,
13423    {
13424        const FIELDS: &[&str] = &[
13425            "table_id",
13426            "tableId",
13427            "upstream_column_ids",
13428            "upstreamColumnIds",
13429            "output_indices",
13430            "outputIndices",
13431            "stream_scan_type",
13432            "streamScanType",
13433            "state_table",
13434            "stateTable",
13435            "table_desc",
13436            "tableDesc",
13437            "rate_limit",
13438            "rateLimit",
13439            "snapshot_read_barrier_interval",
13440            "snapshotReadBarrierInterval",
13441            "arrangement_table",
13442            "arrangementTable",
13443            "snapshot_backfill_epoch",
13444            "snapshotBackfillEpoch",
13445        ];
13446
13447        #[allow(clippy::enum_variant_names)]
13448        enum GeneratedField {
13449            TableId,
13450            UpstreamColumnIds,
13451            OutputIndices,
13452            StreamScanType,
13453            StateTable,
13454            TableDesc,
13455            RateLimit,
13456            SnapshotReadBarrierInterval,
13457            ArrangementTable,
13458            SnapshotBackfillEpoch,
13459        }
13460        impl<'de> serde::Deserialize<'de> for GeneratedField {
13461            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13462            where
13463                D: serde::Deserializer<'de>,
13464            {
13465                struct GeneratedVisitor;
13466
13467                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13468                    type Value = GeneratedField;
13469
13470                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13471                        write!(formatter, "expected one of: {:?}", &FIELDS)
13472                    }
13473
13474                    #[allow(unused_variables)]
13475                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13476                    where
13477                        E: serde::de::Error,
13478                    {
13479                        match value {
13480                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
13481                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
13482                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13483                            "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
13484                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13485                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13486                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13487                            "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
13488                            "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
13489                            "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
13490                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13491                        }
13492                    }
13493                }
13494                deserializer.deserialize_identifier(GeneratedVisitor)
13495            }
13496        }
13497        struct GeneratedVisitor;
13498        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13499            type Value = StreamScanNode;
13500
13501            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13502                formatter.write_str("struct stream_plan.StreamScanNode")
13503            }
13504
13505            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
13506                where
13507                    V: serde::de::MapAccess<'de>,
13508            {
13509                let mut table_id__ = None;
13510                let mut upstream_column_ids__ = None;
13511                let mut output_indices__ = None;
13512                let mut stream_scan_type__ = None;
13513                let mut state_table__ = None;
13514                let mut table_desc__ = None;
13515                let mut rate_limit__ = None;
13516                let mut snapshot_read_barrier_interval__ = None;
13517                let mut arrangement_table__ = None;
13518                let mut snapshot_backfill_epoch__ = None;
13519                while let Some(k) = map_.next_key()? {
13520                    match k {
13521                        GeneratedField::TableId => {
13522                            if table_id__.is_some() {
13523                                return Err(serde::de::Error::duplicate_field("tableId"));
13524                            }
13525                            table_id__ = 
13526                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13527                            ;
13528                        }
13529                        GeneratedField::UpstreamColumnIds => {
13530                            if upstream_column_ids__.is_some() {
13531                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
13532                            }
13533                            upstream_column_ids__ = 
13534                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13535                                    .into_iter().map(|x| x.0).collect())
13536                            ;
13537                        }
13538                        GeneratedField::OutputIndices => {
13539                            if output_indices__.is_some() {
13540                                return Err(serde::de::Error::duplicate_field("outputIndices"));
13541                            }
13542                            output_indices__ = 
13543                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13544                                    .into_iter().map(|x| x.0).collect())
13545                            ;
13546                        }
13547                        GeneratedField::StreamScanType => {
13548                            if stream_scan_type__.is_some() {
13549                                return Err(serde::de::Error::duplicate_field("streamScanType"));
13550                            }
13551                            stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
13552                        }
13553                        GeneratedField::StateTable => {
13554                            if state_table__.is_some() {
13555                                return Err(serde::de::Error::duplicate_field("stateTable"));
13556                            }
13557                            state_table__ = map_.next_value()?;
13558                        }
13559                        GeneratedField::TableDesc => {
13560                            if table_desc__.is_some() {
13561                                return Err(serde::de::Error::duplicate_field("tableDesc"));
13562                            }
13563                            table_desc__ = map_.next_value()?;
13564                        }
13565                        GeneratedField::RateLimit => {
13566                            if rate_limit__.is_some() {
13567                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13568                            }
13569                            rate_limit__ = 
13570                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13571                            ;
13572                        }
13573                        GeneratedField::SnapshotReadBarrierInterval => {
13574                            if snapshot_read_barrier_interval__.is_some() {
13575                                return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
13576                            }
13577                            snapshot_read_barrier_interval__ = 
13578                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13579                            ;
13580                        }
13581                        GeneratedField::ArrangementTable => {
13582                            if arrangement_table__.is_some() {
13583                                return Err(serde::de::Error::duplicate_field("arrangementTable"));
13584                            }
13585                            arrangement_table__ = map_.next_value()?;
13586                        }
13587                        GeneratedField::SnapshotBackfillEpoch => {
13588                            if snapshot_backfill_epoch__.is_some() {
13589                                return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
13590                            }
13591                            snapshot_backfill_epoch__ = 
13592                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13593                            ;
13594                        }
13595                    }
13596                }
13597                Ok(StreamScanNode {
13598                    table_id: table_id__.unwrap_or_default(),
13599                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
13600                    output_indices: output_indices__.unwrap_or_default(),
13601                    stream_scan_type: stream_scan_type__.unwrap_or_default(),
13602                    state_table: state_table__,
13603                    table_desc: table_desc__,
13604                    rate_limit: rate_limit__,
13605                    snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
13606                    arrangement_table: arrangement_table__,
13607                    snapshot_backfill_epoch: snapshot_backfill_epoch__,
13608                })
13609            }
13610        }
13611        deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
13612    }
13613}
13614impl serde::Serialize for StreamScanType {
13615    #[allow(deprecated)]
13616    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13617    where
13618        S: serde::Serializer,
13619    {
13620        let variant = match self {
13621            Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
13622            Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
13623            Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
13624            Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
13625            Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13626            Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13627            Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13628            Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13629        };
13630        serializer.serialize_str(variant)
13631    }
13632}
13633impl<'de> serde::Deserialize<'de> for StreamScanType {
13634    #[allow(deprecated)]
13635    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13636    where
13637        D: serde::Deserializer<'de>,
13638    {
13639        const FIELDS: &[&str] = &[
13640            "STREAM_SCAN_TYPE_UNSPECIFIED",
13641            "STREAM_SCAN_TYPE_CHAIN",
13642            "STREAM_SCAN_TYPE_REARRANGE",
13643            "STREAM_SCAN_TYPE_BACKFILL",
13644            "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13645            "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13646            "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13647            "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13648        ];
13649
13650        struct GeneratedVisitor;
13651
13652        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13653            type Value = StreamScanType;
13654
13655            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13656                write!(formatter, "expected one of: {:?}", &FIELDS)
13657            }
13658
13659            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13660            where
13661                E: serde::de::Error,
13662            {
13663                i32::try_from(v)
13664                    .ok()
13665                    .and_then(|x| x.try_into().ok())
13666                    .ok_or_else(|| {
13667                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13668                    })
13669            }
13670
13671            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13672            where
13673                E: serde::de::Error,
13674            {
13675                i32::try_from(v)
13676                    .ok()
13677                    .and_then(|x| x.try_into().ok())
13678                    .ok_or_else(|| {
13679                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13680                    })
13681            }
13682
13683            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13684            where
13685                E: serde::de::Error,
13686            {
13687                match value {
13688                    "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
13689                    "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
13690                    "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
13691                    "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
13692                    "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
13693                    "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
13694                    "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
13695                    "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
13696                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13697                }
13698            }
13699        }
13700        deserializer.deserialize_any(GeneratedVisitor)
13701    }
13702}
13703impl serde::Serialize for StreamSource {
13704    #[allow(deprecated)]
13705    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13706    where
13707        S: serde::Serializer,
13708    {
13709        use serde::ser::SerializeStruct;
13710        let mut len = 0;
13711        if self.source_id != 0 {
13712            len += 1;
13713        }
13714        if self.state_table.is_some() {
13715            len += 1;
13716        }
13717        if self.row_id_index.is_some() {
13718            len += 1;
13719        }
13720        if !self.columns.is_empty() {
13721            len += 1;
13722        }
13723        if !self.with_properties.is_empty() {
13724            len += 1;
13725        }
13726        if self.info.is_some() {
13727            len += 1;
13728        }
13729        if !self.source_name.is_empty() {
13730            len += 1;
13731        }
13732        if self.rate_limit.is_some() {
13733            len += 1;
13734        }
13735        if !self.secret_refs.is_empty() {
13736            len += 1;
13737        }
13738        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
13739        if self.source_id != 0 {
13740            struct_ser.serialize_field("sourceId", &self.source_id)?;
13741        }
13742        if let Some(v) = self.state_table.as_ref() {
13743            struct_ser.serialize_field("stateTable", v)?;
13744        }
13745        if let Some(v) = self.row_id_index.as_ref() {
13746            struct_ser.serialize_field("rowIdIndex", v)?;
13747        }
13748        if !self.columns.is_empty() {
13749            struct_ser.serialize_field("columns", &self.columns)?;
13750        }
13751        if !self.with_properties.is_empty() {
13752            struct_ser.serialize_field("withProperties", &self.with_properties)?;
13753        }
13754        if let Some(v) = self.info.as_ref() {
13755            struct_ser.serialize_field("info", v)?;
13756        }
13757        if !self.source_name.is_empty() {
13758            struct_ser.serialize_field("sourceName", &self.source_name)?;
13759        }
13760        if let Some(v) = self.rate_limit.as_ref() {
13761            struct_ser.serialize_field("rateLimit", v)?;
13762        }
13763        if !self.secret_refs.is_empty() {
13764            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13765        }
13766        struct_ser.end()
13767    }
13768}
13769impl<'de> serde::Deserialize<'de> for StreamSource {
13770    #[allow(deprecated)]
13771    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13772    where
13773        D: serde::Deserializer<'de>,
13774    {
13775        const FIELDS: &[&str] = &[
13776            "source_id",
13777            "sourceId",
13778            "state_table",
13779            "stateTable",
13780            "row_id_index",
13781            "rowIdIndex",
13782            "columns",
13783            "with_properties",
13784            "withProperties",
13785            "info",
13786            "source_name",
13787            "sourceName",
13788            "rate_limit",
13789            "rateLimit",
13790            "secret_refs",
13791            "secretRefs",
13792        ];
13793
13794        #[allow(clippy::enum_variant_names)]
13795        enum GeneratedField {
13796            SourceId,
13797            StateTable,
13798            RowIdIndex,
13799            Columns,
13800            WithProperties,
13801            Info,
13802            SourceName,
13803            RateLimit,
13804            SecretRefs,
13805        }
13806        impl<'de> serde::Deserialize<'de> for GeneratedField {
13807            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13808            where
13809                D: serde::Deserializer<'de>,
13810            {
13811                struct GeneratedVisitor;
13812
13813                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13814                    type Value = GeneratedField;
13815
13816                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13817                        write!(formatter, "expected one of: {:?}", &FIELDS)
13818                    }
13819
13820                    #[allow(unused_variables)]
13821                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13822                    where
13823                        E: serde::de::Error,
13824                    {
13825                        match value {
13826                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13827                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13828                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13829                            "columns" => Ok(GeneratedField::Columns),
13830                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13831                            "info" => Ok(GeneratedField::Info),
13832                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13833                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13834                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13835                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13836                        }
13837                    }
13838                }
13839                deserializer.deserialize_identifier(GeneratedVisitor)
13840            }
13841        }
13842        struct GeneratedVisitor;
13843        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13844            type Value = StreamSource;
13845
13846            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13847                formatter.write_str("struct stream_plan.StreamSource")
13848            }
13849
13850            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13851                where
13852                    V: serde::de::MapAccess<'de>,
13853            {
13854                let mut source_id__ = None;
13855                let mut state_table__ = None;
13856                let mut row_id_index__ = None;
13857                let mut columns__ = None;
13858                let mut with_properties__ = None;
13859                let mut info__ = None;
13860                let mut source_name__ = None;
13861                let mut rate_limit__ = None;
13862                let mut secret_refs__ = None;
13863                while let Some(k) = map_.next_key()? {
13864                    match k {
13865                        GeneratedField::SourceId => {
13866                            if source_id__.is_some() {
13867                                return Err(serde::de::Error::duplicate_field("sourceId"));
13868                            }
13869                            source_id__ = 
13870                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13871                            ;
13872                        }
13873                        GeneratedField::StateTable => {
13874                            if state_table__.is_some() {
13875                                return Err(serde::de::Error::duplicate_field("stateTable"));
13876                            }
13877                            state_table__ = map_.next_value()?;
13878                        }
13879                        GeneratedField::RowIdIndex => {
13880                            if row_id_index__.is_some() {
13881                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13882                            }
13883                            row_id_index__ = 
13884                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13885                            ;
13886                        }
13887                        GeneratedField::Columns => {
13888                            if columns__.is_some() {
13889                                return Err(serde::de::Error::duplicate_field("columns"));
13890                            }
13891                            columns__ = Some(map_.next_value()?);
13892                        }
13893                        GeneratedField::WithProperties => {
13894                            if with_properties__.is_some() {
13895                                return Err(serde::de::Error::duplicate_field("withProperties"));
13896                            }
13897                            with_properties__ = Some(
13898                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13899                            );
13900                        }
13901                        GeneratedField::Info => {
13902                            if info__.is_some() {
13903                                return Err(serde::de::Error::duplicate_field("info"));
13904                            }
13905                            info__ = map_.next_value()?;
13906                        }
13907                        GeneratedField::SourceName => {
13908                            if source_name__.is_some() {
13909                                return Err(serde::de::Error::duplicate_field("sourceName"));
13910                            }
13911                            source_name__ = Some(map_.next_value()?);
13912                        }
13913                        GeneratedField::RateLimit => {
13914                            if rate_limit__.is_some() {
13915                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13916                            }
13917                            rate_limit__ = 
13918                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13919                            ;
13920                        }
13921                        GeneratedField::SecretRefs => {
13922                            if secret_refs__.is_some() {
13923                                return Err(serde::de::Error::duplicate_field("secretRefs"));
13924                            }
13925                            secret_refs__ = Some(
13926                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13927                            );
13928                        }
13929                    }
13930                }
13931                Ok(StreamSource {
13932                    source_id: source_id__.unwrap_or_default(),
13933                    state_table: state_table__,
13934                    row_id_index: row_id_index__,
13935                    columns: columns__.unwrap_or_default(),
13936                    with_properties: with_properties__.unwrap_or_default(),
13937                    info: info__,
13938                    source_name: source_name__.unwrap_or_default(),
13939                    rate_limit: rate_limit__,
13940                    secret_refs: secret_refs__.unwrap_or_default(),
13941                })
13942            }
13943        }
13944        deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13945    }
13946}
13947impl serde::Serialize for SubscriptionUpstreamInfo {
13948    #[allow(deprecated)]
13949    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13950    where
13951        S: serde::Serializer,
13952    {
13953        use serde::ser::SerializeStruct;
13954        let mut len = 0;
13955        if self.subscriber_id != 0 {
13956            len += 1;
13957        }
13958        if self.upstream_mv_table_id != 0 {
13959            len += 1;
13960        }
13961        let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13962        if self.subscriber_id != 0 {
13963            struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13964        }
13965        if self.upstream_mv_table_id != 0 {
13966            struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13967        }
13968        struct_ser.end()
13969    }
13970}
13971impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13972    #[allow(deprecated)]
13973    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13974    where
13975        D: serde::Deserializer<'de>,
13976    {
13977        const FIELDS: &[&str] = &[
13978            "subscriber_id",
13979            "subscriberId",
13980            "upstream_mv_table_id",
13981            "upstreamMvTableId",
13982        ];
13983
13984        #[allow(clippy::enum_variant_names)]
13985        enum GeneratedField {
13986            SubscriberId,
13987            UpstreamMvTableId,
13988        }
13989        impl<'de> serde::Deserialize<'de> for GeneratedField {
13990            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13991            where
13992                D: serde::Deserializer<'de>,
13993            {
13994                struct GeneratedVisitor;
13995
13996                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13997                    type Value = GeneratedField;
13998
13999                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14000                        write!(formatter, "expected one of: {:?}", &FIELDS)
14001                    }
14002
14003                    #[allow(unused_variables)]
14004                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14005                    where
14006                        E: serde::de::Error,
14007                    {
14008                        match value {
14009                            "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
14010                            "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
14011                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14012                        }
14013                    }
14014                }
14015                deserializer.deserialize_identifier(GeneratedVisitor)
14016            }
14017        }
14018        struct GeneratedVisitor;
14019        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14020            type Value = SubscriptionUpstreamInfo;
14021
14022            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14023                formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
14024            }
14025
14026            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
14027                where
14028                    V: serde::de::MapAccess<'de>,
14029            {
14030                let mut subscriber_id__ = None;
14031                let mut upstream_mv_table_id__ = None;
14032                while let Some(k) = map_.next_key()? {
14033                    match k {
14034                        GeneratedField::SubscriberId => {
14035                            if subscriber_id__.is_some() {
14036                                return Err(serde::de::Error::duplicate_field("subscriberId"));
14037                            }
14038                            subscriber_id__ = 
14039                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14040                            ;
14041                        }
14042                        GeneratedField::UpstreamMvTableId => {
14043                            if upstream_mv_table_id__.is_some() {
14044                                return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
14045                            }
14046                            upstream_mv_table_id__ = 
14047                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14048                            ;
14049                        }
14050                    }
14051                }
14052                Ok(SubscriptionUpstreamInfo {
14053                    subscriber_id: subscriber_id__.unwrap_or_default(),
14054                    upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
14055                })
14056            }
14057        }
14058        deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
14059    }
14060}
14061impl serde::Serialize for SyncLogStoreNode {
14062    #[allow(deprecated)]
14063    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14064    where
14065        S: serde::Serializer,
14066    {
14067        use serde::ser::SerializeStruct;
14068        let mut len = 0;
14069        if self.log_store_table.is_some() {
14070            len += 1;
14071        }
14072        if self.pause_duration_ms != 0 {
14073            len += 1;
14074        }
14075        if self.buffer_size != 0 {
14076            len += 1;
14077        }
14078        if self.aligned {
14079            len += 1;
14080        }
14081        let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
14082        if let Some(v) = self.log_store_table.as_ref() {
14083            struct_ser.serialize_field("logStoreTable", v)?;
14084        }
14085        if self.pause_duration_ms != 0 {
14086            struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
14087        }
14088        if self.buffer_size != 0 {
14089            struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
14090        }
14091        if self.aligned {
14092            struct_ser.serialize_field("aligned", &self.aligned)?;
14093        }
14094        struct_ser.end()
14095    }
14096}
14097impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
14098    #[allow(deprecated)]
14099    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14100    where
14101        D: serde::Deserializer<'de>,
14102    {
14103        const FIELDS: &[&str] = &[
14104            "log_store_table",
14105            "logStoreTable",
14106            "pause_duration_ms",
14107            "pauseDurationMs",
14108            "buffer_size",
14109            "bufferSize",
14110            "aligned",
14111        ];
14112
14113        #[allow(clippy::enum_variant_names)]
14114        enum GeneratedField {
14115            LogStoreTable,
14116            PauseDurationMs,
14117            BufferSize,
14118            Aligned,
14119        }
14120        impl<'de> serde::Deserialize<'de> for GeneratedField {
14121            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14122            where
14123                D: serde::Deserializer<'de>,
14124            {
14125                struct GeneratedVisitor;
14126
14127                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14128                    type Value = GeneratedField;
14129
14130                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14131                        write!(formatter, "expected one of: {:?}", &FIELDS)
14132                    }
14133
14134                    #[allow(unused_variables)]
14135                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14136                    where
14137                        E: serde::de::Error,
14138                    {
14139                        match value {
14140                            "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
14141                            "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
14142                            "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
14143                            "aligned" => Ok(GeneratedField::Aligned),
14144                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14145                        }
14146                    }
14147                }
14148                deserializer.deserialize_identifier(GeneratedVisitor)
14149            }
14150        }
14151        struct GeneratedVisitor;
14152        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14153            type Value = SyncLogStoreNode;
14154
14155            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14156                formatter.write_str("struct stream_plan.SyncLogStoreNode")
14157            }
14158
14159            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
14160                where
14161                    V: serde::de::MapAccess<'de>,
14162            {
14163                let mut log_store_table__ = None;
14164                let mut pause_duration_ms__ = None;
14165                let mut buffer_size__ = None;
14166                let mut aligned__ = None;
14167                while let Some(k) = map_.next_key()? {
14168                    match k {
14169                        GeneratedField::LogStoreTable => {
14170                            if log_store_table__.is_some() {
14171                                return Err(serde::de::Error::duplicate_field("logStoreTable"));
14172                            }
14173                            log_store_table__ = map_.next_value()?;
14174                        }
14175                        GeneratedField::PauseDurationMs => {
14176                            if pause_duration_ms__.is_some() {
14177                                return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14178                            }
14179                            pause_duration_ms__ = 
14180                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14181                            ;
14182                        }
14183                        GeneratedField::BufferSize => {
14184                            if buffer_size__.is_some() {
14185                                return Err(serde::de::Error::duplicate_field("bufferSize"));
14186                            }
14187                            buffer_size__ = 
14188                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14189                            ;
14190                        }
14191                        GeneratedField::Aligned => {
14192                            if aligned__.is_some() {
14193                                return Err(serde::de::Error::duplicate_field("aligned"));
14194                            }
14195                            aligned__ = Some(map_.next_value()?);
14196                        }
14197                    }
14198                }
14199                Ok(SyncLogStoreNode {
14200                    log_store_table: log_store_table__,
14201                    pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14202                    buffer_size: buffer_size__.unwrap_or_default(),
14203                    aligned: aligned__.unwrap_or_default(),
14204                })
14205            }
14206        }
14207        deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14208    }
14209}
14210impl serde::Serialize for TemporalJoinNode {
14211    #[allow(deprecated)]
14212    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14213    where
14214        S: serde::Serializer,
14215    {
14216        use serde::ser::SerializeStruct;
14217        let mut len = 0;
14218        if self.join_type != 0 {
14219            len += 1;
14220        }
14221        if !self.left_key.is_empty() {
14222            len += 1;
14223        }
14224        if !self.right_key.is_empty() {
14225            len += 1;
14226        }
14227        if !self.null_safe.is_empty() {
14228            len += 1;
14229        }
14230        if self.condition.is_some() {
14231            len += 1;
14232        }
14233        if !self.output_indices.is_empty() {
14234            len += 1;
14235        }
14236        if self.table_desc.is_some() {
14237            len += 1;
14238        }
14239        if !self.table_output_indices.is_empty() {
14240            len += 1;
14241        }
14242        if self.memo_table.is_some() {
14243            len += 1;
14244        }
14245        if self.is_nested_loop {
14246            len += 1;
14247        }
14248        let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14249        if self.join_type != 0 {
14250            let v = super::plan_common::JoinType::try_from(self.join_type)
14251                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14252            struct_ser.serialize_field("joinType", &v)?;
14253        }
14254        if !self.left_key.is_empty() {
14255            struct_ser.serialize_field("leftKey", &self.left_key)?;
14256        }
14257        if !self.right_key.is_empty() {
14258            struct_ser.serialize_field("rightKey", &self.right_key)?;
14259        }
14260        if !self.null_safe.is_empty() {
14261            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14262        }
14263        if let Some(v) = self.condition.as_ref() {
14264            struct_ser.serialize_field("condition", v)?;
14265        }
14266        if !self.output_indices.is_empty() {
14267            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14268        }
14269        if let Some(v) = self.table_desc.as_ref() {
14270            struct_ser.serialize_field("tableDesc", v)?;
14271        }
14272        if !self.table_output_indices.is_empty() {
14273            struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14274        }
14275        if let Some(v) = self.memo_table.as_ref() {
14276            struct_ser.serialize_field("memoTable", v)?;
14277        }
14278        if self.is_nested_loop {
14279            struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14280        }
14281        struct_ser.end()
14282    }
14283}
14284impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14285    #[allow(deprecated)]
14286    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14287    where
14288        D: serde::Deserializer<'de>,
14289    {
14290        const FIELDS: &[&str] = &[
14291            "join_type",
14292            "joinType",
14293            "left_key",
14294            "leftKey",
14295            "right_key",
14296            "rightKey",
14297            "null_safe",
14298            "nullSafe",
14299            "condition",
14300            "output_indices",
14301            "outputIndices",
14302            "table_desc",
14303            "tableDesc",
14304            "table_output_indices",
14305            "tableOutputIndices",
14306            "memo_table",
14307            "memoTable",
14308            "is_nested_loop",
14309            "isNestedLoop",
14310        ];
14311
14312        #[allow(clippy::enum_variant_names)]
14313        enum GeneratedField {
14314            JoinType,
14315            LeftKey,
14316            RightKey,
14317            NullSafe,
14318            Condition,
14319            OutputIndices,
14320            TableDesc,
14321            TableOutputIndices,
14322            MemoTable,
14323            IsNestedLoop,
14324        }
14325        impl<'de> serde::Deserialize<'de> for GeneratedField {
14326            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14327            where
14328                D: serde::Deserializer<'de>,
14329            {
14330                struct GeneratedVisitor;
14331
14332                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14333                    type Value = GeneratedField;
14334
14335                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14336                        write!(formatter, "expected one of: {:?}", &FIELDS)
14337                    }
14338
14339                    #[allow(unused_variables)]
14340                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14341                    where
14342                        E: serde::de::Error,
14343                    {
14344                        match value {
14345                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14346                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14347                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14348                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14349                            "condition" => Ok(GeneratedField::Condition),
14350                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14351                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14352                            "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14353                            "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14354                            "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14355                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14356                        }
14357                    }
14358                }
14359                deserializer.deserialize_identifier(GeneratedVisitor)
14360            }
14361        }
14362        struct GeneratedVisitor;
14363        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14364            type Value = TemporalJoinNode;
14365
14366            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14367                formatter.write_str("struct stream_plan.TemporalJoinNode")
14368            }
14369
14370            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14371                where
14372                    V: serde::de::MapAccess<'de>,
14373            {
14374                let mut join_type__ = None;
14375                let mut left_key__ = None;
14376                let mut right_key__ = None;
14377                let mut null_safe__ = None;
14378                let mut condition__ = None;
14379                let mut output_indices__ = None;
14380                let mut table_desc__ = None;
14381                let mut table_output_indices__ = None;
14382                let mut memo_table__ = None;
14383                let mut is_nested_loop__ = None;
14384                while let Some(k) = map_.next_key()? {
14385                    match k {
14386                        GeneratedField::JoinType => {
14387                            if join_type__.is_some() {
14388                                return Err(serde::de::Error::duplicate_field("joinType"));
14389                            }
14390                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14391                        }
14392                        GeneratedField::LeftKey => {
14393                            if left_key__.is_some() {
14394                                return Err(serde::de::Error::duplicate_field("leftKey"));
14395                            }
14396                            left_key__ = 
14397                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14398                                    .into_iter().map(|x| x.0).collect())
14399                            ;
14400                        }
14401                        GeneratedField::RightKey => {
14402                            if right_key__.is_some() {
14403                                return Err(serde::de::Error::duplicate_field("rightKey"));
14404                            }
14405                            right_key__ = 
14406                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14407                                    .into_iter().map(|x| x.0).collect())
14408                            ;
14409                        }
14410                        GeneratedField::NullSafe => {
14411                            if null_safe__.is_some() {
14412                                return Err(serde::de::Error::duplicate_field("nullSafe"));
14413                            }
14414                            null_safe__ = Some(map_.next_value()?);
14415                        }
14416                        GeneratedField::Condition => {
14417                            if condition__.is_some() {
14418                                return Err(serde::de::Error::duplicate_field("condition"));
14419                            }
14420                            condition__ = map_.next_value()?;
14421                        }
14422                        GeneratedField::OutputIndices => {
14423                            if output_indices__.is_some() {
14424                                return Err(serde::de::Error::duplicate_field("outputIndices"));
14425                            }
14426                            output_indices__ = 
14427                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14428                                    .into_iter().map(|x| x.0).collect())
14429                            ;
14430                        }
14431                        GeneratedField::TableDesc => {
14432                            if table_desc__.is_some() {
14433                                return Err(serde::de::Error::duplicate_field("tableDesc"));
14434                            }
14435                            table_desc__ = map_.next_value()?;
14436                        }
14437                        GeneratedField::TableOutputIndices => {
14438                            if table_output_indices__.is_some() {
14439                                return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
14440                            }
14441                            table_output_indices__ = 
14442                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14443                                    .into_iter().map(|x| x.0).collect())
14444                            ;
14445                        }
14446                        GeneratedField::MemoTable => {
14447                            if memo_table__.is_some() {
14448                                return Err(serde::de::Error::duplicate_field("memoTable"));
14449                            }
14450                            memo_table__ = map_.next_value()?;
14451                        }
14452                        GeneratedField::IsNestedLoop => {
14453                            if is_nested_loop__.is_some() {
14454                                return Err(serde::de::Error::duplicate_field("isNestedLoop"));
14455                            }
14456                            is_nested_loop__ = Some(map_.next_value()?);
14457                        }
14458                    }
14459                }
14460                Ok(TemporalJoinNode {
14461                    join_type: join_type__.unwrap_or_default(),
14462                    left_key: left_key__.unwrap_or_default(),
14463                    right_key: right_key__.unwrap_or_default(),
14464                    null_safe: null_safe__.unwrap_or_default(),
14465                    condition: condition__,
14466                    output_indices: output_indices__.unwrap_or_default(),
14467                    table_desc: table_desc__,
14468                    table_output_indices: table_output_indices__.unwrap_or_default(),
14469                    memo_table: memo_table__,
14470                    is_nested_loop: is_nested_loop__.unwrap_or_default(),
14471                })
14472            }
14473        }
14474        deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
14475    }
14476}
14477impl serde::Serialize for ThrottleMutation {
14478    #[allow(deprecated)]
14479    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14480    where
14481        S: serde::Serializer,
14482    {
14483        use serde::ser::SerializeStruct;
14484        let mut len = 0;
14485        if !self.actor_throttle.is_empty() {
14486            len += 1;
14487        }
14488        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
14489        if !self.actor_throttle.is_empty() {
14490            struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
14491        }
14492        struct_ser.end()
14493    }
14494}
14495impl<'de> serde::Deserialize<'de> for ThrottleMutation {
14496    #[allow(deprecated)]
14497    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14498    where
14499        D: serde::Deserializer<'de>,
14500    {
14501        const FIELDS: &[&str] = &[
14502            "actor_throttle",
14503            "actorThrottle",
14504        ];
14505
14506        #[allow(clippy::enum_variant_names)]
14507        enum GeneratedField {
14508            ActorThrottle,
14509        }
14510        impl<'de> serde::Deserialize<'de> for GeneratedField {
14511            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14512            where
14513                D: serde::Deserializer<'de>,
14514            {
14515                struct GeneratedVisitor;
14516
14517                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14518                    type Value = GeneratedField;
14519
14520                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14521                        write!(formatter, "expected one of: {:?}", &FIELDS)
14522                    }
14523
14524                    #[allow(unused_variables)]
14525                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14526                    where
14527                        E: serde::de::Error,
14528                    {
14529                        match value {
14530                            "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
14531                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14532                        }
14533                    }
14534                }
14535                deserializer.deserialize_identifier(GeneratedVisitor)
14536            }
14537        }
14538        struct GeneratedVisitor;
14539        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14540            type Value = ThrottleMutation;
14541
14542            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14543                formatter.write_str("struct stream_plan.ThrottleMutation")
14544            }
14545
14546            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
14547                where
14548                    V: serde::de::MapAccess<'de>,
14549            {
14550                let mut actor_throttle__ = None;
14551                while let Some(k) = map_.next_key()? {
14552                    match k {
14553                        GeneratedField::ActorThrottle => {
14554                            if actor_throttle__.is_some() {
14555                                return Err(serde::de::Error::duplicate_field("actorThrottle"));
14556                            }
14557                            actor_throttle__ = Some(
14558                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14559                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14560                            );
14561                        }
14562                    }
14563                }
14564                Ok(ThrottleMutation {
14565                    actor_throttle: actor_throttle__.unwrap_or_default(),
14566                })
14567            }
14568        }
14569        deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
14570    }
14571}
14572impl serde::Serialize for throttle_mutation::RateLimit {
14573    #[allow(deprecated)]
14574    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14575    where
14576        S: serde::Serializer,
14577    {
14578        use serde::ser::SerializeStruct;
14579        let mut len = 0;
14580        if self.rate_limit.is_some() {
14581            len += 1;
14582        }
14583        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
14584        if let Some(v) = self.rate_limit.as_ref() {
14585            struct_ser.serialize_field("rateLimit", v)?;
14586        }
14587        struct_ser.end()
14588    }
14589}
14590impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
14591    #[allow(deprecated)]
14592    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14593    where
14594        D: serde::Deserializer<'de>,
14595    {
14596        const FIELDS: &[&str] = &[
14597            "rate_limit",
14598            "rateLimit",
14599        ];
14600
14601        #[allow(clippy::enum_variant_names)]
14602        enum GeneratedField {
14603            RateLimit,
14604        }
14605        impl<'de> serde::Deserialize<'de> for GeneratedField {
14606            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14607            where
14608                D: serde::Deserializer<'de>,
14609            {
14610                struct GeneratedVisitor;
14611
14612                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14613                    type Value = GeneratedField;
14614
14615                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14616                        write!(formatter, "expected one of: {:?}", &FIELDS)
14617                    }
14618
14619                    #[allow(unused_variables)]
14620                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14621                    where
14622                        E: serde::de::Error,
14623                    {
14624                        match value {
14625                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14626                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14627                        }
14628                    }
14629                }
14630                deserializer.deserialize_identifier(GeneratedVisitor)
14631            }
14632        }
14633        struct GeneratedVisitor;
14634        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14635            type Value = throttle_mutation::RateLimit;
14636
14637            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14638                formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
14639            }
14640
14641            fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
14642                where
14643                    V: serde::de::MapAccess<'de>,
14644            {
14645                let mut rate_limit__ = None;
14646                while let Some(k) = map_.next_key()? {
14647                    match k {
14648                        GeneratedField::RateLimit => {
14649                            if rate_limit__.is_some() {
14650                                return Err(serde::de::Error::duplicate_field("rateLimit"));
14651                            }
14652                            rate_limit__ = 
14653                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14654                            ;
14655                        }
14656                    }
14657                }
14658                Ok(throttle_mutation::RateLimit {
14659                    rate_limit: rate_limit__,
14660                })
14661            }
14662        }
14663        deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
14664    }
14665}
14666impl serde::Serialize for TopNNode {
14667    #[allow(deprecated)]
14668    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14669    where
14670        S: serde::Serializer,
14671    {
14672        use serde::ser::SerializeStruct;
14673        let mut len = 0;
14674        if self.limit != 0 {
14675            len += 1;
14676        }
14677        if self.offset != 0 {
14678            len += 1;
14679        }
14680        if self.table.is_some() {
14681            len += 1;
14682        }
14683        if !self.order_by.is_empty() {
14684            len += 1;
14685        }
14686        if self.with_ties {
14687            len += 1;
14688        }
14689        let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
14690        if self.limit != 0 {
14691            #[allow(clippy::needless_borrow)]
14692            #[allow(clippy::needless_borrows_for_generic_args)]
14693            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
14694        }
14695        if self.offset != 0 {
14696            #[allow(clippy::needless_borrow)]
14697            #[allow(clippy::needless_borrows_for_generic_args)]
14698            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
14699        }
14700        if let Some(v) = self.table.as_ref() {
14701            struct_ser.serialize_field("table", v)?;
14702        }
14703        if !self.order_by.is_empty() {
14704            struct_ser.serialize_field("orderBy", &self.order_by)?;
14705        }
14706        if self.with_ties {
14707            struct_ser.serialize_field("withTies", &self.with_ties)?;
14708        }
14709        struct_ser.end()
14710    }
14711}
14712impl<'de> serde::Deserialize<'de> for TopNNode {
14713    #[allow(deprecated)]
14714    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14715    where
14716        D: serde::Deserializer<'de>,
14717    {
14718        const FIELDS: &[&str] = &[
14719            "limit",
14720            "offset",
14721            "table",
14722            "order_by",
14723            "orderBy",
14724            "with_ties",
14725            "withTies",
14726        ];
14727
14728        #[allow(clippy::enum_variant_names)]
14729        enum GeneratedField {
14730            Limit,
14731            Offset,
14732            Table,
14733            OrderBy,
14734            WithTies,
14735        }
14736        impl<'de> serde::Deserialize<'de> for GeneratedField {
14737            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14738            where
14739                D: serde::Deserializer<'de>,
14740            {
14741                struct GeneratedVisitor;
14742
14743                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14744                    type Value = GeneratedField;
14745
14746                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14747                        write!(formatter, "expected one of: {:?}", &FIELDS)
14748                    }
14749
14750                    #[allow(unused_variables)]
14751                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14752                    where
14753                        E: serde::de::Error,
14754                    {
14755                        match value {
14756                            "limit" => Ok(GeneratedField::Limit),
14757                            "offset" => Ok(GeneratedField::Offset),
14758                            "table" => Ok(GeneratedField::Table),
14759                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
14760                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
14761                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14762                        }
14763                    }
14764                }
14765                deserializer.deserialize_identifier(GeneratedVisitor)
14766            }
14767        }
14768        struct GeneratedVisitor;
14769        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14770            type Value = TopNNode;
14771
14772            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14773                formatter.write_str("struct stream_plan.TopNNode")
14774            }
14775
14776            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
14777                where
14778                    V: serde::de::MapAccess<'de>,
14779            {
14780                let mut limit__ = None;
14781                let mut offset__ = None;
14782                let mut table__ = None;
14783                let mut order_by__ = None;
14784                let mut with_ties__ = None;
14785                while let Some(k) = map_.next_key()? {
14786                    match k {
14787                        GeneratedField::Limit => {
14788                            if limit__.is_some() {
14789                                return Err(serde::de::Error::duplicate_field("limit"));
14790                            }
14791                            limit__ = 
14792                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14793                            ;
14794                        }
14795                        GeneratedField::Offset => {
14796                            if offset__.is_some() {
14797                                return Err(serde::de::Error::duplicate_field("offset"));
14798                            }
14799                            offset__ = 
14800                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14801                            ;
14802                        }
14803                        GeneratedField::Table => {
14804                            if table__.is_some() {
14805                                return Err(serde::de::Error::duplicate_field("table"));
14806                            }
14807                            table__ = map_.next_value()?;
14808                        }
14809                        GeneratedField::OrderBy => {
14810                            if order_by__.is_some() {
14811                                return Err(serde::de::Error::duplicate_field("orderBy"));
14812                            }
14813                            order_by__ = Some(map_.next_value()?);
14814                        }
14815                        GeneratedField::WithTies => {
14816                            if with_ties__.is_some() {
14817                                return Err(serde::de::Error::duplicate_field("withTies"));
14818                            }
14819                            with_ties__ = Some(map_.next_value()?);
14820                        }
14821                    }
14822                }
14823                Ok(TopNNode {
14824                    limit: limit__.unwrap_or_default(),
14825                    offset: offset__.unwrap_or_default(),
14826                    table: table__,
14827                    order_by: order_by__.unwrap_or_default(),
14828                    with_ties: with_ties__.unwrap_or_default(),
14829                })
14830            }
14831        }
14832        deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14833    }
14834}
14835impl serde::Serialize for UnionNode {
14836    #[allow(deprecated)]
14837    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14838    where
14839        S: serde::Serializer,
14840    {
14841        use serde::ser::SerializeStruct;
14842        let len = 0;
14843        let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14844        struct_ser.end()
14845    }
14846}
14847impl<'de> serde::Deserialize<'de> for UnionNode {
14848    #[allow(deprecated)]
14849    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14850    where
14851        D: serde::Deserializer<'de>,
14852    {
14853        const FIELDS: &[&str] = &[
14854        ];
14855
14856        #[allow(clippy::enum_variant_names)]
14857        enum GeneratedField {
14858        }
14859        impl<'de> serde::Deserialize<'de> for GeneratedField {
14860            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14861            where
14862                D: serde::Deserializer<'de>,
14863            {
14864                struct GeneratedVisitor;
14865
14866                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14867                    type Value = GeneratedField;
14868
14869                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14870                        write!(formatter, "expected one of: {:?}", &FIELDS)
14871                    }
14872
14873                    #[allow(unused_variables)]
14874                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14875                    where
14876                        E: serde::de::Error,
14877                    {
14878                            Err(serde::de::Error::unknown_field(value, FIELDS))
14879                    }
14880                }
14881                deserializer.deserialize_identifier(GeneratedVisitor)
14882            }
14883        }
14884        struct GeneratedVisitor;
14885        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14886            type Value = UnionNode;
14887
14888            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14889                formatter.write_str("struct stream_plan.UnionNode")
14890            }
14891
14892            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14893                where
14894                    V: serde::de::MapAccess<'de>,
14895            {
14896                while map_.next_key::<GeneratedField>()?.is_some() {
14897                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14898                }
14899                Ok(UnionNode {
14900                })
14901            }
14902        }
14903        deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14904    }
14905}
14906impl serde::Serialize for UpdateMutation {
14907    #[allow(deprecated)]
14908    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14909    where
14910        S: serde::Serializer,
14911    {
14912        use serde::ser::SerializeStruct;
14913        let mut len = 0;
14914        if !self.dispatcher_update.is_empty() {
14915            len += 1;
14916        }
14917        if !self.merge_update.is_empty() {
14918            len += 1;
14919        }
14920        if !self.actor_vnode_bitmap_update.is_empty() {
14921            len += 1;
14922        }
14923        if !self.dropped_actors.is_empty() {
14924            len += 1;
14925        }
14926        if !self.actor_splits.is_empty() {
14927            len += 1;
14928        }
14929        if !self.actor_new_dispatchers.is_empty() {
14930            len += 1;
14931        }
14932        if self.actor_cdc_table_snapshot_splits.is_some() {
14933            len += 1;
14934        }
14935        if !self.sink_add_columns.is_empty() {
14936            len += 1;
14937        }
14938        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14939        if !self.dispatcher_update.is_empty() {
14940            struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14941        }
14942        if !self.merge_update.is_empty() {
14943            struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14944        }
14945        if !self.actor_vnode_bitmap_update.is_empty() {
14946            struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14947        }
14948        if !self.dropped_actors.is_empty() {
14949            struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14950        }
14951        if !self.actor_splits.is_empty() {
14952            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14953        }
14954        if !self.actor_new_dispatchers.is_empty() {
14955            struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14956        }
14957        if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
14958            struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
14959        }
14960        if !self.sink_add_columns.is_empty() {
14961            struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
14962        }
14963        struct_ser.end()
14964    }
14965}
14966impl<'de> serde::Deserialize<'de> for UpdateMutation {
14967    #[allow(deprecated)]
14968    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14969    where
14970        D: serde::Deserializer<'de>,
14971    {
14972        const FIELDS: &[&str] = &[
14973            "dispatcher_update",
14974            "dispatcherUpdate",
14975            "merge_update",
14976            "mergeUpdate",
14977            "actor_vnode_bitmap_update",
14978            "actorVnodeBitmapUpdate",
14979            "dropped_actors",
14980            "droppedActors",
14981            "actor_splits",
14982            "actorSplits",
14983            "actor_new_dispatchers",
14984            "actorNewDispatchers",
14985            "actor_cdc_table_snapshot_splits",
14986            "actorCdcTableSnapshotSplits",
14987            "sink_add_columns",
14988            "sinkAddColumns",
14989        ];
14990
14991        #[allow(clippy::enum_variant_names)]
14992        enum GeneratedField {
14993            DispatcherUpdate,
14994            MergeUpdate,
14995            ActorVnodeBitmapUpdate,
14996            DroppedActors,
14997            ActorSplits,
14998            ActorNewDispatchers,
14999            ActorCdcTableSnapshotSplits,
15000            SinkAddColumns,
15001        }
15002        impl<'de> serde::Deserialize<'de> for GeneratedField {
15003            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15004            where
15005                D: serde::Deserializer<'de>,
15006            {
15007                struct GeneratedVisitor;
15008
15009                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15010                    type Value = GeneratedField;
15011
15012                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15013                        write!(formatter, "expected one of: {:?}", &FIELDS)
15014                    }
15015
15016                    #[allow(unused_variables)]
15017                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15018                    where
15019                        E: serde::de::Error,
15020                    {
15021                        match value {
15022                            "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
15023                            "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
15024                            "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
15025                            "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
15026                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15027                            "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
15028                            "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
15029                            "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
15030                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15031                        }
15032                    }
15033                }
15034                deserializer.deserialize_identifier(GeneratedVisitor)
15035            }
15036        }
15037        struct GeneratedVisitor;
15038        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15039            type Value = UpdateMutation;
15040
15041            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15042                formatter.write_str("struct stream_plan.UpdateMutation")
15043            }
15044
15045            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
15046                where
15047                    V: serde::de::MapAccess<'de>,
15048            {
15049                let mut dispatcher_update__ = None;
15050                let mut merge_update__ = None;
15051                let mut actor_vnode_bitmap_update__ = None;
15052                let mut dropped_actors__ = None;
15053                let mut actor_splits__ = None;
15054                let mut actor_new_dispatchers__ = None;
15055                let mut actor_cdc_table_snapshot_splits__ = None;
15056                let mut sink_add_columns__ = None;
15057                while let Some(k) = map_.next_key()? {
15058                    match k {
15059                        GeneratedField::DispatcherUpdate => {
15060                            if dispatcher_update__.is_some() {
15061                                return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
15062                            }
15063                            dispatcher_update__ = Some(map_.next_value()?);
15064                        }
15065                        GeneratedField::MergeUpdate => {
15066                            if merge_update__.is_some() {
15067                                return Err(serde::de::Error::duplicate_field("mergeUpdate"));
15068                            }
15069                            merge_update__ = Some(map_.next_value()?);
15070                        }
15071                        GeneratedField::ActorVnodeBitmapUpdate => {
15072                            if actor_vnode_bitmap_update__.is_some() {
15073                                return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
15074                            }
15075                            actor_vnode_bitmap_update__ = Some(
15076                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15077                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15078                            );
15079                        }
15080                        GeneratedField::DroppedActors => {
15081                            if dropped_actors__.is_some() {
15082                                return Err(serde::de::Error::duplicate_field("droppedActors"));
15083                            }
15084                            dropped_actors__ = 
15085                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15086                                    .into_iter().map(|x| x.0).collect())
15087                            ;
15088                        }
15089                        GeneratedField::ActorSplits => {
15090                            if actor_splits__.is_some() {
15091                                return Err(serde::de::Error::duplicate_field("actorSplits"));
15092                            }
15093                            actor_splits__ = Some(
15094                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15095                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15096                            );
15097                        }
15098                        GeneratedField::ActorNewDispatchers => {
15099                            if actor_new_dispatchers__.is_some() {
15100                                return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
15101                            }
15102                            actor_new_dispatchers__ = Some(
15103                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15104                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15105                            );
15106                        }
15107                        GeneratedField::ActorCdcTableSnapshotSplits => {
15108                            if actor_cdc_table_snapshot_splits__.is_some() {
15109                                return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
15110                            }
15111                            actor_cdc_table_snapshot_splits__ = map_.next_value()?;
15112                        }
15113                        GeneratedField::SinkAddColumns => {
15114                            if sink_add_columns__.is_some() {
15115                                return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
15116                            }
15117                            sink_add_columns__ = Some(
15118                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15119                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15120                            );
15121                        }
15122                    }
15123                }
15124                Ok(UpdateMutation {
15125                    dispatcher_update: dispatcher_update__.unwrap_or_default(),
15126                    merge_update: merge_update__.unwrap_or_default(),
15127                    actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
15128                    dropped_actors: dropped_actors__.unwrap_or_default(),
15129                    actor_splits: actor_splits__.unwrap_or_default(),
15130                    actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
15131                    actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
15132                    sink_add_columns: sink_add_columns__.unwrap_or_default(),
15133                })
15134            }
15135        }
15136        deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
15137    }
15138}
15139impl serde::Serialize for update_mutation::DispatcherUpdate {
15140    #[allow(deprecated)]
15141    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15142    where
15143        S: serde::Serializer,
15144    {
15145        use serde::ser::SerializeStruct;
15146        let mut len = 0;
15147        if self.actor_id != 0 {
15148            len += 1;
15149        }
15150        if self.dispatcher_id != 0 {
15151            len += 1;
15152        }
15153        if self.hash_mapping.is_some() {
15154            len += 1;
15155        }
15156        if !self.added_downstream_actor_id.is_empty() {
15157            len += 1;
15158        }
15159        if !self.removed_downstream_actor_id.is_empty() {
15160            len += 1;
15161        }
15162        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15163        if self.actor_id != 0 {
15164            struct_ser.serialize_field("actorId", &self.actor_id)?;
15165        }
15166        if self.dispatcher_id != 0 {
15167            #[allow(clippy::needless_borrow)]
15168            #[allow(clippy::needless_borrows_for_generic_args)]
15169            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15170        }
15171        if let Some(v) = self.hash_mapping.as_ref() {
15172            struct_ser.serialize_field("hashMapping", v)?;
15173        }
15174        if !self.added_downstream_actor_id.is_empty() {
15175            struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15176        }
15177        if !self.removed_downstream_actor_id.is_empty() {
15178            struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15179        }
15180        struct_ser.end()
15181    }
15182}
15183impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15184    #[allow(deprecated)]
15185    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15186    where
15187        D: serde::Deserializer<'de>,
15188    {
15189        const FIELDS: &[&str] = &[
15190            "actor_id",
15191            "actorId",
15192            "dispatcher_id",
15193            "dispatcherId",
15194            "hash_mapping",
15195            "hashMapping",
15196            "added_downstream_actor_id",
15197            "addedDownstreamActorId",
15198            "removed_downstream_actor_id",
15199            "removedDownstreamActorId",
15200        ];
15201
15202        #[allow(clippy::enum_variant_names)]
15203        enum GeneratedField {
15204            ActorId,
15205            DispatcherId,
15206            HashMapping,
15207            AddedDownstreamActorId,
15208            RemovedDownstreamActorId,
15209        }
15210        impl<'de> serde::Deserialize<'de> for GeneratedField {
15211            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15212            where
15213                D: serde::Deserializer<'de>,
15214            {
15215                struct GeneratedVisitor;
15216
15217                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15218                    type Value = GeneratedField;
15219
15220                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15221                        write!(formatter, "expected one of: {:?}", &FIELDS)
15222                    }
15223
15224                    #[allow(unused_variables)]
15225                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15226                    where
15227                        E: serde::de::Error,
15228                    {
15229                        match value {
15230                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15231                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15232                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15233                            "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15234                            "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15235                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15236                        }
15237                    }
15238                }
15239                deserializer.deserialize_identifier(GeneratedVisitor)
15240            }
15241        }
15242        struct GeneratedVisitor;
15243        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15244            type Value = update_mutation::DispatcherUpdate;
15245
15246            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15247                formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15248            }
15249
15250            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15251                where
15252                    V: serde::de::MapAccess<'de>,
15253            {
15254                let mut actor_id__ = None;
15255                let mut dispatcher_id__ = None;
15256                let mut hash_mapping__ = None;
15257                let mut added_downstream_actor_id__ = None;
15258                let mut removed_downstream_actor_id__ = None;
15259                while let Some(k) = map_.next_key()? {
15260                    match k {
15261                        GeneratedField::ActorId => {
15262                            if actor_id__.is_some() {
15263                                return Err(serde::de::Error::duplicate_field("actorId"));
15264                            }
15265                            actor_id__ = 
15266                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15267                            ;
15268                        }
15269                        GeneratedField::DispatcherId => {
15270                            if dispatcher_id__.is_some() {
15271                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
15272                            }
15273                            dispatcher_id__ = 
15274                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15275                            ;
15276                        }
15277                        GeneratedField::HashMapping => {
15278                            if hash_mapping__.is_some() {
15279                                return Err(serde::de::Error::duplicate_field("hashMapping"));
15280                            }
15281                            hash_mapping__ = map_.next_value()?;
15282                        }
15283                        GeneratedField::AddedDownstreamActorId => {
15284                            if added_downstream_actor_id__.is_some() {
15285                                return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15286                            }
15287                            added_downstream_actor_id__ = 
15288                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15289                                    .into_iter().map(|x| x.0).collect())
15290                            ;
15291                        }
15292                        GeneratedField::RemovedDownstreamActorId => {
15293                            if removed_downstream_actor_id__.is_some() {
15294                                return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15295                            }
15296                            removed_downstream_actor_id__ = 
15297                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15298                                    .into_iter().map(|x| x.0).collect())
15299                            ;
15300                        }
15301                    }
15302                }
15303                Ok(update_mutation::DispatcherUpdate {
15304                    actor_id: actor_id__.unwrap_or_default(),
15305                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
15306                    hash_mapping: hash_mapping__,
15307                    added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15308                    removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15309                })
15310            }
15311        }
15312        deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15313    }
15314}
15315impl serde::Serialize for update_mutation::MergeUpdate {
15316    #[allow(deprecated)]
15317    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15318    where
15319        S: serde::Serializer,
15320    {
15321        use serde::ser::SerializeStruct;
15322        let mut len = 0;
15323        if self.actor_id != 0 {
15324            len += 1;
15325        }
15326        if self.upstream_fragment_id != 0 {
15327            len += 1;
15328        }
15329        if self.new_upstream_fragment_id.is_some() {
15330            len += 1;
15331        }
15332        if !self.added_upstream_actors.is_empty() {
15333            len += 1;
15334        }
15335        if !self.removed_upstream_actor_id.is_empty() {
15336            len += 1;
15337        }
15338        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15339        if self.actor_id != 0 {
15340            struct_ser.serialize_field("actorId", &self.actor_id)?;
15341        }
15342        if self.upstream_fragment_id != 0 {
15343            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15344        }
15345        if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15346            struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15347        }
15348        if !self.added_upstream_actors.is_empty() {
15349            struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15350        }
15351        if !self.removed_upstream_actor_id.is_empty() {
15352            struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15353        }
15354        struct_ser.end()
15355    }
15356}
15357impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15358    #[allow(deprecated)]
15359    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15360    where
15361        D: serde::Deserializer<'de>,
15362    {
15363        const FIELDS: &[&str] = &[
15364            "actor_id",
15365            "actorId",
15366            "upstream_fragment_id",
15367            "upstreamFragmentId",
15368            "new_upstream_fragment_id",
15369            "newUpstreamFragmentId",
15370            "added_upstream_actors",
15371            "addedUpstreamActors",
15372            "removed_upstream_actor_id",
15373            "removedUpstreamActorId",
15374        ];
15375
15376        #[allow(clippy::enum_variant_names)]
15377        enum GeneratedField {
15378            ActorId,
15379            UpstreamFragmentId,
15380            NewUpstreamFragmentId,
15381            AddedUpstreamActors,
15382            RemovedUpstreamActorId,
15383        }
15384        impl<'de> serde::Deserialize<'de> for GeneratedField {
15385            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15386            where
15387                D: serde::Deserializer<'de>,
15388            {
15389                struct GeneratedVisitor;
15390
15391                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15392                    type Value = GeneratedField;
15393
15394                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15395                        write!(formatter, "expected one of: {:?}", &FIELDS)
15396                    }
15397
15398                    #[allow(unused_variables)]
15399                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15400                    where
15401                        E: serde::de::Error,
15402                    {
15403                        match value {
15404                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15405                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15406                            "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
15407                            "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
15408                            "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
15409                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15410                        }
15411                    }
15412                }
15413                deserializer.deserialize_identifier(GeneratedVisitor)
15414            }
15415        }
15416        struct GeneratedVisitor;
15417        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15418            type Value = update_mutation::MergeUpdate;
15419
15420            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15421                formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
15422            }
15423
15424            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
15425                where
15426                    V: serde::de::MapAccess<'de>,
15427            {
15428                let mut actor_id__ = None;
15429                let mut upstream_fragment_id__ = None;
15430                let mut new_upstream_fragment_id__ = None;
15431                let mut added_upstream_actors__ = None;
15432                let mut removed_upstream_actor_id__ = None;
15433                while let Some(k) = map_.next_key()? {
15434                    match k {
15435                        GeneratedField::ActorId => {
15436                            if actor_id__.is_some() {
15437                                return Err(serde::de::Error::duplicate_field("actorId"));
15438                            }
15439                            actor_id__ = 
15440                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15441                            ;
15442                        }
15443                        GeneratedField::UpstreamFragmentId => {
15444                            if upstream_fragment_id__.is_some() {
15445                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15446                            }
15447                            upstream_fragment_id__ = 
15448                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15449                            ;
15450                        }
15451                        GeneratedField::NewUpstreamFragmentId => {
15452                            if new_upstream_fragment_id__.is_some() {
15453                                return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
15454                            }
15455                            new_upstream_fragment_id__ = 
15456                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15457                            ;
15458                        }
15459                        GeneratedField::AddedUpstreamActors => {
15460                            if added_upstream_actors__.is_some() {
15461                                return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
15462                            }
15463                            added_upstream_actors__ = Some(map_.next_value()?);
15464                        }
15465                        GeneratedField::RemovedUpstreamActorId => {
15466                            if removed_upstream_actor_id__.is_some() {
15467                                return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
15468                            }
15469                            removed_upstream_actor_id__ = 
15470                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15471                                    .into_iter().map(|x| x.0).collect())
15472                            ;
15473                        }
15474                    }
15475                }
15476                Ok(update_mutation::MergeUpdate {
15477                    actor_id: actor_id__.unwrap_or_default(),
15478                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15479                    new_upstream_fragment_id: new_upstream_fragment_id__,
15480                    added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
15481                    removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
15482                })
15483            }
15484        }
15485        deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
15486    }
15487}
15488impl serde::Serialize for UpstreamSinkInfo {
15489    #[allow(deprecated)]
15490    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15491    where
15492        S: serde::Serializer,
15493    {
15494        use serde::ser::SerializeStruct;
15495        let mut len = 0;
15496        if self.upstream_fragment_id != 0 {
15497            len += 1;
15498        }
15499        if !self.sink_output_schema.is_empty() {
15500            len += 1;
15501        }
15502        if !self.project_exprs.is_empty() {
15503            len += 1;
15504        }
15505        let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
15506        if self.upstream_fragment_id != 0 {
15507            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15508        }
15509        if !self.sink_output_schema.is_empty() {
15510            struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
15511        }
15512        if !self.project_exprs.is_empty() {
15513            struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
15514        }
15515        struct_ser.end()
15516    }
15517}
15518impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
15519    #[allow(deprecated)]
15520    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15521    where
15522        D: serde::Deserializer<'de>,
15523    {
15524        const FIELDS: &[&str] = &[
15525            "upstream_fragment_id",
15526            "upstreamFragmentId",
15527            "sink_output_schema",
15528            "sinkOutputSchema",
15529            "project_exprs",
15530            "projectExprs",
15531        ];
15532
15533        #[allow(clippy::enum_variant_names)]
15534        enum GeneratedField {
15535            UpstreamFragmentId,
15536            SinkOutputSchema,
15537            ProjectExprs,
15538        }
15539        impl<'de> serde::Deserialize<'de> for GeneratedField {
15540            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15541            where
15542                D: serde::Deserializer<'de>,
15543            {
15544                struct GeneratedVisitor;
15545
15546                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15547                    type Value = GeneratedField;
15548
15549                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15550                        write!(formatter, "expected one of: {:?}", &FIELDS)
15551                    }
15552
15553                    #[allow(unused_variables)]
15554                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15555                    where
15556                        E: serde::de::Error,
15557                    {
15558                        match value {
15559                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15560                            "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
15561                            "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
15562                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15563                        }
15564                    }
15565                }
15566                deserializer.deserialize_identifier(GeneratedVisitor)
15567            }
15568        }
15569        struct GeneratedVisitor;
15570        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15571            type Value = UpstreamSinkInfo;
15572
15573            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15574                formatter.write_str("struct stream_plan.UpstreamSinkInfo")
15575            }
15576
15577            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
15578                where
15579                    V: serde::de::MapAccess<'de>,
15580            {
15581                let mut upstream_fragment_id__ = None;
15582                let mut sink_output_schema__ = None;
15583                let mut project_exprs__ = None;
15584                while let Some(k) = map_.next_key()? {
15585                    match k {
15586                        GeneratedField::UpstreamFragmentId => {
15587                            if upstream_fragment_id__.is_some() {
15588                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15589                            }
15590                            upstream_fragment_id__ = 
15591                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15592                            ;
15593                        }
15594                        GeneratedField::SinkOutputSchema => {
15595                            if sink_output_schema__.is_some() {
15596                                return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
15597                            }
15598                            sink_output_schema__ = Some(map_.next_value()?);
15599                        }
15600                        GeneratedField::ProjectExprs => {
15601                            if project_exprs__.is_some() {
15602                                return Err(serde::de::Error::duplicate_field("projectExprs"));
15603                            }
15604                            project_exprs__ = Some(map_.next_value()?);
15605                        }
15606                    }
15607                }
15608                Ok(UpstreamSinkInfo {
15609                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15610                    sink_output_schema: sink_output_schema__.unwrap_or_default(),
15611                    project_exprs: project_exprs__.unwrap_or_default(),
15612                })
15613            }
15614        }
15615        deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
15616    }
15617}
15618impl serde::Serialize for UpstreamSinkUnionNode {
15619    #[allow(deprecated)]
15620    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15621    where
15622        S: serde::Serializer,
15623    {
15624        use serde::ser::SerializeStruct;
15625        let mut len = 0;
15626        if !self.init_upstreams.is_empty() {
15627            len += 1;
15628        }
15629        let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
15630        if !self.init_upstreams.is_empty() {
15631            struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
15632        }
15633        struct_ser.end()
15634    }
15635}
15636impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
15637    #[allow(deprecated)]
15638    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15639    where
15640        D: serde::Deserializer<'de>,
15641    {
15642        const FIELDS: &[&str] = &[
15643            "init_upstreams",
15644            "initUpstreams",
15645        ];
15646
15647        #[allow(clippy::enum_variant_names)]
15648        enum GeneratedField {
15649            InitUpstreams,
15650        }
15651        impl<'de> serde::Deserialize<'de> for GeneratedField {
15652            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15653            where
15654                D: serde::Deserializer<'de>,
15655            {
15656                struct GeneratedVisitor;
15657
15658                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15659                    type Value = GeneratedField;
15660
15661                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15662                        write!(formatter, "expected one of: {:?}", &FIELDS)
15663                    }
15664
15665                    #[allow(unused_variables)]
15666                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15667                    where
15668                        E: serde::de::Error,
15669                    {
15670                        match value {
15671                            "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
15672                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15673                        }
15674                    }
15675                }
15676                deserializer.deserialize_identifier(GeneratedVisitor)
15677            }
15678        }
15679        struct GeneratedVisitor;
15680        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15681            type Value = UpstreamSinkUnionNode;
15682
15683            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15684                formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
15685            }
15686
15687            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
15688                where
15689                    V: serde::de::MapAccess<'de>,
15690            {
15691                let mut init_upstreams__ = None;
15692                while let Some(k) = map_.next_key()? {
15693                    match k {
15694                        GeneratedField::InitUpstreams => {
15695                            if init_upstreams__.is_some() {
15696                                return Err(serde::de::Error::duplicate_field("initUpstreams"));
15697                            }
15698                            init_upstreams__ = Some(map_.next_value()?);
15699                        }
15700                    }
15701                }
15702                Ok(UpstreamSinkUnionNode {
15703                    init_upstreams: init_upstreams__.unwrap_or_default(),
15704                })
15705            }
15706        }
15707        deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
15708    }
15709}
15710impl serde::Serialize for ValuesNode {
15711    #[allow(deprecated)]
15712    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15713    where
15714        S: serde::Serializer,
15715    {
15716        use serde::ser::SerializeStruct;
15717        let mut len = 0;
15718        if !self.tuples.is_empty() {
15719            len += 1;
15720        }
15721        if !self.fields.is_empty() {
15722            len += 1;
15723        }
15724        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
15725        if !self.tuples.is_empty() {
15726            struct_ser.serialize_field("tuples", &self.tuples)?;
15727        }
15728        if !self.fields.is_empty() {
15729            struct_ser.serialize_field("fields", &self.fields)?;
15730        }
15731        struct_ser.end()
15732    }
15733}
15734impl<'de> serde::Deserialize<'de> for ValuesNode {
15735    #[allow(deprecated)]
15736    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15737    where
15738        D: serde::Deserializer<'de>,
15739    {
15740        const FIELDS: &[&str] = &[
15741            "tuples",
15742            "fields",
15743        ];
15744
15745        #[allow(clippy::enum_variant_names)]
15746        enum GeneratedField {
15747            Tuples,
15748            Fields,
15749        }
15750        impl<'de> serde::Deserialize<'de> for GeneratedField {
15751            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15752            where
15753                D: serde::Deserializer<'de>,
15754            {
15755                struct GeneratedVisitor;
15756
15757                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15758                    type Value = GeneratedField;
15759
15760                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15761                        write!(formatter, "expected one of: {:?}", &FIELDS)
15762                    }
15763
15764                    #[allow(unused_variables)]
15765                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15766                    where
15767                        E: serde::de::Error,
15768                    {
15769                        match value {
15770                            "tuples" => Ok(GeneratedField::Tuples),
15771                            "fields" => Ok(GeneratedField::Fields),
15772                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15773                        }
15774                    }
15775                }
15776                deserializer.deserialize_identifier(GeneratedVisitor)
15777            }
15778        }
15779        struct GeneratedVisitor;
15780        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15781            type Value = ValuesNode;
15782
15783            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15784                formatter.write_str("struct stream_plan.ValuesNode")
15785            }
15786
15787            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
15788                where
15789                    V: serde::de::MapAccess<'de>,
15790            {
15791                let mut tuples__ = None;
15792                let mut fields__ = None;
15793                while let Some(k) = map_.next_key()? {
15794                    match k {
15795                        GeneratedField::Tuples => {
15796                            if tuples__.is_some() {
15797                                return Err(serde::de::Error::duplicate_field("tuples"));
15798                            }
15799                            tuples__ = Some(map_.next_value()?);
15800                        }
15801                        GeneratedField::Fields => {
15802                            if fields__.is_some() {
15803                                return Err(serde::de::Error::duplicate_field("fields"));
15804                            }
15805                            fields__ = Some(map_.next_value()?);
15806                        }
15807                    }
15808                }
15809                Ok(ValuesNode {
15810                    tuples: tuples__.unwrap_or_default(),
15811                    fields: fields__.unwrap_or_default(),
15812                })
15813            }
15814        }
15815        deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
15816    }
15817}
15818impl serde::Serialize for values_node::ExprTuple {
15819    #[allow(deprecated)]
15820    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15821    where
15822        S: serde::Serializer,
15823    {
15824        use serde::ser::SerializeStruct;
15825        let mut len = 0;
15826        if !self.cells.is_empty() {
15827            len += 1;
15828        }
15829        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
15830        if !self.cells.is_empty() {
15831            struct_ser.serialize_field("cells", &self.cells)?;
15832        }
15833        struct_ser.end()
15834    }
15835}
15836impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
15837    #[allow(deprecated)]
15838    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15839    where
15840        D: serde::Deserializer<'de>,
15841    {
15842        const FIELDS: &[&str] = &[
15843            "cells",
15844        ];
15845
15846        #[allow(clippy::enum_variant_names)]
15847        enum GeneratedField {
15848            Cells,
15849        }
15850        impl<'de> serde::Deserialize<'de> for GeneratedField {
15851            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15852            where
15853                D: serde::Deserializer<'de>,
15854            {
15855                struct GeneratedVisitor;
15856
15857                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15858                    type Value = GeneratedField;
15859
15860                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15861                        write!(formatter, "expected one of: {:?}", &FIELDS)
15862                    }
15863
15864                    #[allow(unused_variables)]
15865                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15866                    where
15867                        E: serde::de::Error,
15868                    {
15869                        match value {
15870                            "cells" => Ok(GeneratedField::Cells),
15871                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15872                        }
15873                    }
15874                }
15875                deserializer.deserialize_identifier(GeneratedVisitor)
15876            }
15877        }
15878        struct GeneratedVisitor;
15879        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15880            type Value = values_node::ExprTuple;
15881
15882            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15883                formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
15884            }
15885
15886            fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
15887                where
15888                    V: serde::de::MapAccess<'de>,
15889            {
15890                let mut cells__ = None;
15891                while let Some(k) = map_.next_key()? {
15892                    match k {
15893                        GeneratedField::Cells => {
15894                            if cells__.is_some() {
15895                                return Err(serde::de::Error::duplicate_field("cells"));
15896                            }
15897                            cells__ = Some(map_.next_value()?);
15898                        }
15899                    }
15900                }
15901                Ok(values_node::ExprTuple {
15902                    cells: cells__.unwrap_or_default(),
15903                })
15904            }
15905        }
15906        deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
15907    }
15908}
15909impl serde::Serialize for VectorIndexWriteNode {
15910    #[allow(deprecated)]
15911    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15912    where
15913        S: serde::Serializer,
15914    {
15915        use serde::ser::SerializeStruct;
15916        let mut len = 0;
15917        if self.table.is_some() {
15918            len += 1;
15919        }
15920        let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
15921        if let Some(v) = self.table.as_ref() {
15922            struct_ser.serialize_field("table", v)?;
15923        }
15924        struct_ser.end()
15925    }
15926}
15927impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
15928    #[allow(deprecated)]
15929    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15930    where
15931        D: serde::Deserializer<'de>,
15932    {
15933        const FIELDS: &[&str] = &[
15934            "table",
15935        ];
15936
15937        #[allow(clippy::enum_variant_names)]
15938        enum GeneratedField {
15939            Table,
15940        }
15941        impl<'de> serde::Deserialize<'de> for GeneratedField {
15942            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15943            where
15944                D: serde::Deserializer<'de>,
15945            {
15946                struct GeneratedVisitor;
15947
15948                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15949                    type Value = GeneratedField;
15950
15951                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15952                        write!(formatter, "expected one of: {:?}", &FIELDS)
15953                    }
15954
15955                    #[allow(unused_variables)]
15956                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15957                    where
15958                        E: serde::de::Error,
15959                    {
15960                        match value {
15961                            "table" => Ok(GeneratedField::Table),
15962                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15963                        }
15964                    }
15965                }
15966                deserializer.deserialize_identifier(GeneratedVisitor)
15967            }
15968        }
15969        struct GeneratedVisitor;
15970        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15971            type Value = VectorIndexWriteNode;
15972
15973            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15974                formatter.write_str("struct stream_plan.VectorIndexWriteNode")
15975            }
15976
15977            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
15978                where
15979                    V: serde::de::MapAccess<'de>,
15980            {
15981                let mut table__ = None;
15982                while let Some(k) = map_.next_key()? {
15983                    match k {
15984                        GeneratedField::Table => {
15985                            if table__.is_some() {
15986                                return Err(serde::de::Error::duplicate_field("table"));
15987                            }
15988                            table__ = map_.next_value()?;
15989                        }
15990                    }
15991                }
15992                Ok(VectorIndexWriteNode {
15993                    table: table__,
15994                })
15995            }
15996        }
15997        deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
15998    }
15999}
16000impl serde::Serialize for Watermark {
16001    #[allow(deprecated)]
16002    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16003    where
16004        S: serde::Serializer,
16005    {
16006        use serde::ser::SerializeStruct;
16007        let mut len = 0;
16008        if self.column.is_some() {
16009            len += 1;
16010        }
16011        if self.val.is_some() {
16012            len += 1;
16013        }
16014        let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
16015        if let Some(v) = self.column.as_ref() {
16016            struct_ser.serialize_field("column", v)?;
16017        }
16018        if let Some(v) = self.val.as_ref() {
16019            struct_ser.serialize_field("val", v)?;
16020        }
16021        struct_ser.end()
16022    }
16023}
16024impl<'de> serde::Deserialize<'de> for Watermark {
16025    #[allow(deprecated)]
16026    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16027    where
16028        D: serde::Deserializer<'de>,
16029    {
16030        const FIELDS: &[&str] = &[
16031            "column",
16032            "val",
16033        ];
16034
16035        #[allow(clippy::enum_variant_names)]
16036        enum GeneratedField {
16037            Column,
16038            Val,
16039        }
16040        impl<'de> serde::Deserialize<'de> for GeneratedField {
16041            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16042            where
16043                D: serde::Deserializer<'de>,
16044            {
16045                struct GeneratedVisitor;
16046
16047                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16048                    type Value = GeneratedField;
16049
16050                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16051                        write!(formatter, "expected one of: {:?}", &FIELDS)
16052                    }
16053
16054                    #[allow(unused_variables)]
16055                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16056                    where
16057                        E: serde::de::Error,
16058                    {
16059                        match value {
16060                            "column" => Ok(GeneratedField::Column),
16061                            "val" => Ok(GeneratedField::Val),
16062                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16063                        }
16064                    }
16065                }
16066                deserializer.deserialize_identifier(GeneratedVisitor)
16067            }
16068        }
16069        struct GeneratedVisitor;
16070        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16071            type Value = Watermark;
16072
16073            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16074                formatter.write_str("struct stream_plan.Watermark")
16075            }
16076
16077            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
16078                where
16079                    V: serde::de::MapAccess<'de>,
16080            {
16081                let mut column__ = None;
16082                let mut val__ = None;
16083                while let Some(k) = map_.next_key()? {
16084                    match k {
16085                        GeneratedField::Column => {
16086                            if column__.is_some() {
16087                                return Err(serde::de::Error::duplicate_field("column"));
16088                            }
16089                            column__ = map_.next_value()?;
16090                        }
16091                        GeneratedField::Val => {
16092                            if val__.is_some() {
16093                                return Err(serde::de::Error::duplicate_field("val"));
16094                            }
16095                            val__ = map_.next_value()?;
16096                        }
16097                    }
16098                }
16099                Ok(Watermark {
16100                    column: column__,
16101                    val: val__,
16102                })
16103            }
16104        }
16105        deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
16106    }
16107}
16108impl serde::Serialize for WatermarkFilterNode {
16109    #[allow(deprecated)]
16110    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16111    where
16112        S: serde::Serializer,
16113    {
16114        use serde::ser::SerializeStruct;
16115        let mut len = 0;
16116        if !self.watermark_descs.is_empty() {
16117            len += 1;
16118        }
16119        if !self.tables.is_empty() {
16120            len += 1;
16121        }
16122        let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
16123        if !self.watermark_descs.is_empty() {
16124            struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
16125        }
16126        if !self.tables.is_empty() {
16127            struct_ser.serialize_field("tables", &self.tables)?;
16128        }
16129        struct_ser.end()
16130    }
16131}
16132impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
16133    #[allow(deprecated)]
16134    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16135    where
16136        D: serde::Deserializer<'de>,
16137    {
16138        const FIELDS: &[&str] = &[
16139            "watermark_descs",
16140            "watermarkDescs",
16141            "tables",
16142        ];
16143
16144        #[allow(clippy::enum_variant_names)]
16145        enum GeneratedField {
16146            WatermarkDescs,
16147            Tables,
16148        }
16149        impl<'de> serde::Deserialize<'de> for GeneratedField {
16150            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16151            where
16152                D: serde::Deserializer<'de>,
16153            {
16154                struct GeneratedVisitor;
16155
16156                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16157                    type Value = GeneratedField;
16158
16159                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16160                        write!(formatter, "expected one of: {:?}", &FIELDS)
16161                    }
16162
16163                    #[allow(unused_variables)]
16164                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16165                    where
16166                        E: serde::de::Error,
16167                    {
16168                        match value {
16169                            "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16170                            "tables" => Ok(GeneratedField::Tables),
16171                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16172                        }
16173                    }
16174                }
16175                deserializer.deserialize_identifier(GeneratedVisitor)
16176            }
16177        }
16178        struct GeneratedVisitor;
16179        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16180            type Value = WatermarkFilterNode;
16181
16182            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16183                formatter.write_str("struct stream_plan.WatermarkFilterNode")
16184            }
16185
16186            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16187                where
16188                    V: serde::de::MapAccess<'de>,
16189            {
16190                let mut watermark_descs__ = None;
16191                let mut tables__ = None;
16192                while let Some(k) = map_.next_key()? {
16193                    match k {
16194                        GeneratedField::WatermarkDescs => {
16195                            if watermark_descs__.is_some() {
16196                                return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16197                            }
16198                            watermark_descs__ = Some(map_.next_value()?);
16199                        }
16200                        GeneratedField::Tables => {
16201                            if tables__.is_some() {
16202                                return Err(serde::de::Error::duplicate_field("tables"));
16203                            }
16204                            tables__ = Some(map_.next_value()?);
16205                        }
16206                    }
16207                }
16208                Ok(WatermarkFilterNode {
16209                    watermark_descs: watermark_descs__.unwrap_or_default(),
16210                    tables: tables__.unwrap_or_default(),
16211                })
16212            }
16213        }
16214        deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16215    }
16216}