risingwave_pb/
stream_service.serde.rs

1use crate::stream_service::*;
2impl serde::Serialize for BarrierCompleteResponse {
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.request_id.is_empty() {
11            len += 1;
12        }
13        if self.status.is_some() {
14            len += 1;
15        }
16        if !self.create_mview_progress.is_empty() {
17            len += 1;
18        }
19        if !self.synced_sstables.is_empty() {
20            len += 1;
21        }
22        if self.worker_id != 0 {
23            len += 1;
24        }
25        if !self.table_watermarks.is_empty() {
26            len += 1;
27        }
28        if !self.old_value_sstables.is_empty() {
29            len += 1;
30        }
31        if self.partial_graph_id != 0 {
32            len += 1;
33        }
34        if self.epoch != 0 {
35            len += 1;
36        }
37        if self.database_id != 0 {
38            len += 1;
39        }
40        if !self.load_finished_source_ids.is_empty() {
41            len += 1;
42        }
43        if !self.vector_index_adds.is_empty() {
44            len += 1;
45        }
46        if !self.cdc_table_backfill_progress.is_empty() {
47            len += 1;
48        }
49        let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse", len)?;
50        if !self.request_id.is_empty() {
51            struct_ser.serialize_field("requestId", &self.request_id)?;
52        }
53        if let Some(v) = self.status.as_ref() {
54            struct_ser.serialize_field("status", v)?;
55        }
56        if !self.create_mview_progress.is_empty() {
57            struct_ser.serialize_field("createMviewProgress", &self.create_mview_progress)?;
58        }
59        if !self.synced_sstables.is_empty() {
60            struct_ser.serialize_field("syncedSstables", &self.synced_sstables)?;
61        }
62        if self.worker_id != 0 {
63            struct_ser.serialize_field("workerId", &self.worker_id)?;
64        }
65        if !self.table_watermarks.is_empty() {
66            struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
67        }
68        if !self.old_value_sstables.is_empty() {
69            struct_ser.serialize_field("oldValueSstables", &self.old_value_sstables)?;
70        }
71        if self.partial_graph_id != 0 {
72            struct_ser.serialize_field("partialGraphId", &self.partial_graph_id)?;
73        }
74        if self.epoch != 0 {
75            #[allow(clippy::needless_borrow)]
76            #[allow(clippy::needless_borrows_for_generic_args)]
77            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
78        }
79        if self.database_id != 0 {
80            struct_ser.serialize_field("databaseId", &self.database_id)?;
81        }
82        if !self.load_finished_source_ids.is_empty() {
83            struct_ser.serialize_field("loadFinishedSourceIds", &self.load_finished_source_ids)?;
84        }
85        if !self.vector_index_adds.is_empty() {
86            struct_ser.serialize_field("vectorIndexAdds", &self.vector_index_adds)?;
87        }
88        if !self.cdc_table_backfill_progress.is_empty() {
89            struct_ser.serialize_field("cdcTableBackfillProgress", &self.cdc_table_backfill_progress)?;
90        }
91        struct_ser.end()
92    }
93}
94impl<'de> serde::Deserialize<'de> for BarrierCompleteResponse {
95    #[allow(deprecated)]
96    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
97    where
98        D: serde::Deserializer<'de>,
99    {
100        const FIELDS: &[&str] = &[
101            "request_id",
102            "requestId",
103            "status",
104            "create_mview_progress",
105            "createMviewProgress",
106            "synced_sstables",
107            "syncedSstables",
108            "worker_id",
109            "workerId",
110            "table_watermarks",
111            "tableWatermarks",
112            "old_value_sstables",
113            "oldValueSstables",
114            "partial_graph_id",
115            "partialGraphId",
116            "epoch",
117            "database_id",
118            "databaseId",
119            "load_finished_source_ids",
120            "loadFinishedSourceIds",
121            "vector_index_adds",
122            "vectorIndexAdds",
123            "cdc_table_backfill_progress",
124            "cdcTableBackfillProgress",
125        ];
126
127        #[allow(clippy::enum_variant_names)]
128        enum GeneratedField {
129            RequestId,
130            Status,
131            CreateMviewProgress,
132            SyncedSstables,
133            WorkerId,
134            TableWatermarks,
135            OldValueSstables,
136            PartialGraphId,
137            Epoch,
138            DatabaseId,
139            LoadFinishedSourceIds,
140            VectorIndexAdds,
141            CdcTableBackfillProgress,
142        }
143        impl<'de> serde::Deserialize<'de> for GeneratedField {
144            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
145            where
146                D: serde::Deserializer<'de>,
147            {
148                struct GeneratedVisitor;
149
150                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
151                    type Value = GeneratedField;
152
153                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
154                        write!(formatter, "expected one of: {:?}", &FIELDS)
155                    }
156
157                    #[allow(unused_variables)]
158                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
159                    where
160                        E: serde::de::Error,
161                    {
162                        match value {
163                            "requestId" | "request_id" => Ok(GeneratedField::RequestId),
164                            "status" => Ok(GeneratedField::Status),
165                            "createMviewProgress" | "create_mview_progress" => Ok(GeneratedField::CreateMviewProgress),
166                            "syncedSstables" | "synced_sstables" => Ok(GeneratedField::SyncedSstables),
167                            "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
168                            "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
169                            "oldValueSstables" | "old_value_sstables" => Ok(GeneratedField::OldValueSstables),
170                            "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
171                            "epoch" => Ok(GeneratedField::Epoch),
172                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
173                            "loadFinishedSourceIds" | "load_finished_source_ids" => Ok(GeneratedField::LoadFinishedSourceIds),
174                            "vectorIndexAdds" | "vector_index_adds" => Ok(GeneratedField::VectorIndexAdds),
175                            "cdcTableBackfillProgress" | "cdc_table_backfill_progress" => Ok(GeneratedField::CdcTableBackfillProgress),
176                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
177                        }
178                    }
179                }
180                deserializer.deserialize_identifier(GeneratedVisitor)
181            }
182        }
183        struct GeneratedVisitor;
184        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
185            type Value = BarrierCompleteResponse;
186
187            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
188                formatter.write_str("struct stream_service.BarrierCompleteResponse")
189            }
190
191            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierCompleteResponse, V::Error>
192                where
193                    V: serde::de::MapAccess<'de>,
194            {
195                let mut request_id__ = None;
196                let mut status__ = None;
197                let mut create_mview_progress__ = None;
198                let mut synced_sstables__ = None;
199                let mut worker_id__ = None;
200                let mut table_watermarks__ = None;
201                let mut old_value_sstables__ = None;
202                let mut partial_graph_id__ = None;
203                let mut epoch__ = None;
204                let mut database_id__ = None;
205                let mut load_finished_source_ids__ = None;
206                let mut vector_index_adds__ = None;
207                let mut cdc_table_backfill_progress__ = None;
208                while let Some(k) = map_.next_key()? {
209                    match k {
210                        GeneratedField::RequestId => {
211                            if request_id__.is_some() {
212                                return Err(serde::de::Error::duplicate_field("requestId"));
213                            }
214                            request_id__ = Some(map_.next_value()?);
215                        }
216                        GeneratedField::Status => {
217                            if status__.is_some() {
218                                return Err(serde::de::Error::duplicate_field("status"));
219                            }
220                            status__ = map_.next_value()?;
221                        }
222                        GeneratedField::CreateMviewProgress => {
223                            if create_mview_progress__.is_some() {
224                                return Err(serde::de::Error::duplicate_field("createMviewProgress"));
225                            }
226                            create_mview_progress__ = Some(map_.next_value()?);
227                        }
228                        GeneratedField::SyncedSstables => {
229                            if synced_sstables__.is_some() {
230                                return Err(serde::de::Error::duplicate_field("syncedSstables"));
231                            }
232                            synced_sstables__ = Some(map_.next_value()?);
233                        }
234                        GeneratedField::WorkerId => {
235                            if worker_id__.is_some() {
236                                return Err(serde::de::Error::duplicate_field("workerId"));
237                            }
238                            worker_id__ = 
239                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
240                            ;
241                        }
242                        GeneratedField::TableWatermarks => {
243                            if table_watermarks__.is_some() {
244                                return Err(serde::de::Error::duplicate_field("tableWatermarks"));
245                            }
246                            table_watermarks__ = Some(
247                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
248                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
249                            );
250                        }
251                        GeneratedField::OldValueSstables => {
252                            if old_value_sstables__.is_some() {
253                                return Err(serde::de::Error::duplicate_field("oldValueSstables"));
254                            }
255                            old_value_sstables__ = Some(map_.next_value()?);
256                        }
257                        GeneratedField::PartialGraphId => {
258                            if partial_graph_id__.is_some() {
259                                return Err(serde::de::Error::duplicate_field("partialGraphId"));
260                            }
261                            partial_graph_id__ = 
262                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
263                            ;
264                        }
265                        GeneratedField::Epoch => {
266                            if epoch__.is_some() {
267                                return Err(serde::de::Error::duplicate_field("epoch"));
268                            }
269                            epoch__ = 
270                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
271                            ;
272                        }
273                        GeneratedField::DatabaseId => {
274                            if database_id__.is_some() {
275                                return Err(serde::de::Error::duplicate_field("databaseId"));
276                            }
277                            database_id__ = 
278                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
279                            ;
280                        }
281                        GeneratedField::LoadFinishedSourceIds => {
282                            if load_finished_source_ids__.is_some() {
283                                return Err(serde::de::Error::duplicate_field("loadFinishedSourceIds"));
284                            }
285                            load_finished_source_ids__ = 
286                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
287                                    .into_iter().map(|x| x.0).collect())
288                            ;
289                        }
290                        GeneratedField::VectorIndexAdds => {
291                            if vector_index_adds__.is_some() {
292                                return Err(serde::de::Error::duplicate_field("vectorIndexAdds"));
293                            }
294                            vector_index_adds__ = Some(
295                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
296                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
297                            );
298                        }
299                        GeneratedField::CdcTableBackfillProgress => {
300                            if cdc_table_backfill_progress__.is_some() {
301                                return Err(serde::de::Error::duplicate_field("cdcTableBackfillProgress"));
302                            }
303                            cdc_table_backfill_progress__ = Some(map_.next_value()?);
304                        }
305                    }
306                }
307                Ok(BarrierCompleteResponse {
308                    request_id: request_id__.unwrap_or_default(),
309                    status: status__,
310                    create_mview_progress: create_mview_progress__.unwrap_or_default(),
311                    synced_sstables: synced_sstables__.unwrap_or_default(),
312                    worker_id: worker_id__.unwrap_or_default(),
313                    table_watermarks: table_watermarks__.unwrap_or_default(),
314                    old_value_sstables: old_value_sstables__.unwrap_or_default(),
315                    partial_graph_id: partial_graph_id__.unwrap_or_default(),
316                    epoch: epoch__.unwrap_or_default(),
317                    database_id: database_id__.unwrap_or_default(),
318                    load_finished_source_ids: load_finished_source_ids__.unwrap_or_default(),
319                    vector_index_adds: vector_index_adds__.unwrap_or_default(),
320                    cdc_table_backfill_progress: cdc_table_backfill_progress__.unwrap_or_default(),
321                })
322            }
323        }
324        deserializer.deserialize_struct("stream_service.BarrierCompleteResponse", FIELDS, GeneratedVisitor)
325    }
326}
327impl serde::Serialize for barrier_complete_response::CdcTableBackfillProgress {
328    #[allow(deprecated)]
329    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
330    where
331        S: serde::Serializer,
332    {
333        use serde::ser::SerializeStruct;
334        let mut len = 0;
335        if self.actor_id != 0 {
336            len += 1;
337        }
338        if self.epoch != 0 {
339            len += 1;
340        }
341        if self.done {
342            len += 1;
343        }
344        if self.split_id_start_inclusive != 0 {
345            len += 1;
346        }
347        if self.split_id_end_inclusive != 0 {
348            len += 1;
349        }
350        if self.generation != 0 {
351            len += 1;
352        }
353        if self.fragment_id != 0 {
354            len += 1;
355        }
356        let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.CdcTableBackfillProgress", len)?;
357        if self.actor_id != 0 {
358            struct_ser.serialize_field("actorId", &self.actor_id)?;
359        }
360        if self.epoch != 0 {
361            #[allow(clippy::needless_borrow)]
362            #[allow(clippy::needless_borrows_for_generic_args)]
363            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
364        }
365        if self.done {
366            struct_ser.serialize_field("done", &self.done)?;
367        }
368        if self.split_id_start_inclusive != 0 {
369            #[allow(clippy::needless_borrow)]
370            #[allow(clippy::needless_borrows_for_generic_args)]
371            struct_ser.serialize_field("splitIdStartInclusive", ToString::to_string(&self.split_id_start_inclusive).as_str())?;
372        }
373        if self.split_id_end_inclusive != 0 {
374            #[allow(clippy::needless_borrow)]
375            #[allow(clippy::needless_borrows_for_generic_args)]
376            struct_ser.serialize_field("splitIdEndInclusive", ToString::to_string(&self.split_id_end_inclusive).as_str())?;
377        }
378        if self.generation != 0 {
379            #[allow(clippy::needless_borrow)]
380            #[allow(clippy::needless_borrows_for_generic_args)]
381            struct_ser.serialize_field("generation", ToString::to_string(&self.generation).as_str())?;
382        }
383        if self.fragment_id != 0 {
384            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
385        }
386        struct_ser.end()
387    }
388}
389impl<'de> serde::Deserialize<'de> for barrier_complete_response::CdcTableBackfillProgress {
390    #[allow(deprecated)]
391    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
392    where
393        D: serde::Deserializer<'de>,
394    {
395        const FIELDS: &[&str] = &[
396            "actor_id",
397            "actorId",
398            "epoch",
399            "done",
400            "split_id_start_inclusive",
401            "splitIdStartInclusive",
402            "split_id_end_inclusive",
403            "splitIdEndInclusive",
404            "generation",
405            "fragment_id",
406            "fragmentId",
407        ];
408
409        #[allow(clippy::enum_variant_names)]
410        enum GeneratedField {
411            ActorId,
412            Epoch,
413            Done,
414            SplitIdStartInclusive,
415            SplitIdEndInclusive,
416            Generation,
417            FragmentId,
418        }
419        impl<'de> serde::Deserialize<'de> for GeneratedField {
420            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
421            where
422                D: serde::Deserializer<'de>,
423            {
424                struct GeneratedVisitor;
425
426                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
427                    type Value = GeneratedField;
428
429                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
430                        write!(formatter, "expected one of: {:?}", &FIELDS)
431                    }
432
433                    #[allow(unused_variables)]
434                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
435                    where
436                        E: serde::de::Error,
437                    {
438                        match value {
439                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
440                            "epoch" => Ok(GeneratedField::Epoch),
441                            "done" => Ok(GeneratedField::Done),
442                            "splitIdStartInclusive" | "split_id_start_inclusive" => Ok(GeneratedField::SplitIdStartInclusive),
443                            "splitIdEndInclusive" | "split_id_end_inclusive" => Ok(GeneratedField::SplitIdEndInclusive),
444                            "generation" => Ok(GeneratedField::Generation),
445                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
446                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
447                        }
448                    }
449                }
450                deserializer.deserialize_identifier(GeneratedVisitor)
451            }
452        }
453        struct GeneratedVisitor;
454        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
455            type Value = barrier_complete_response::CdcTableBackfillProgress;
456
457            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
458                formatter.write_str("struct stream_service.BarrierCompleteResponse.CdcTableBackfillProgress")
459            }
460
461            fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::CdcTableBackfillProgress, V::Error>
462                where
463                    V: serde::de::MapAccess<'de>,
464            {
465                let mut actor_id__ = None;
466                let mut epoch__ = None;
467                let mut done__ = None;
468                let mut split_id_start_inclusive__ = None;
469                let mut split_id_end_inclusive__ = None;
470                let mut generation__ = None;
471                let mut fragment_id__ = None;
472                while let Some(k) = map_.next_key()? {
473                    match k {
474                        GeneratedField::ActorId => {
475                            if actor_id__.is_some() {
476                                return Err(serde::de::Error::duplicate_field("actorId"));
477                            }
478                            actor_id__ = 
479                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
480                            ;
481                        }
482                        GeneratedField::Epoch => {
483                            if epoch__.is_some() {
484                                return Err(serde::de::Error::duplicate_field("epoch"));
485                            }
486                            epoch__ = 
487                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
488                            ;
489                        }
490                        GeneratedField::Done => {
491                            if done__.is_some() {
492                                return Err(serde::de::Error::duplicate_field("done"));
493                            }
494                            done__ = Some(map_.next_value()?);
495                        }
496                        GeneratedField::SplitIdStartInclusive => {
497                            if split_id_start_inclusive__.is_some() {
498                                return Err(serde::de::Error::duplicate_field("splitIdStartInclusive"));
499                            }
500                            split_id_start_inclusive__ = 
501                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
502                            ;
503                        }
504                        GeneratedField::SplitIdEndInclusive => {
505                            if split_id_end_inclusive__.is_some() {
506                                return Err(serde::de::Error::duplicate_field("splitIdEndInclusive"));
507                            }
508                            split_id_end_inclusive__ = 
509                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
510                            ;
511                        }
512                        GeneratedField::Generation => {
513                            if generation__.is_some() {
514                                return Err(serde::de::Error::duplicate_field("generation"));
515                            }
516                            generation__ = 
517                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
518                            ;
519                        }
520                        GeneratedField::FragmentId => {
521                            if fragment_id__.is_some() {
522                                return Err(serde::de::Error::duplicate_field("fragmentId"));
523                            }
524                            fragment_id__ = 
525                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
526                            ;
527                        }
528                    }
529                }
530                Ok(barrier_complete_response::CdcTableBackfillProgress {
531                    actor_id: actor_id__.unwrap_or_default(),
532                    epoch: epoch__.unwrap_or_default(),
533                    done: done__.unwrap_or_default(),
534                    split_id_start_inclusive: split_id_start_inclusive__.unwrap_or_default(),
535                    split_id_end_inclusive: split_id_end_inclusive__.unwrap_or_default(),
536                    generation: generation__.unwrap_or_default(),
537                    fragment_id: fragment_id__.unwrap_or_default(),
538                })
539            }
540        }
541        deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.CdcTableBackfillProgress", FIELDS, GeneratedVisitor)
542    }
543}
544impl serde::Serialize for barrier_complete_response::CreateMviewProgress {
545    #[allow(deprecated)]
546    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
547    where
548        S: serde::Serializer,
549    {
550        use serde::ser::SerializeStruct;
551        let mut len = 0;
552        if self.backfill_actor_id != 0 {
553            len += 1;
554        }
555        if self.done {
556            len += 1;
557        }
558        if self.consumed_epoch != 0 {
559            len += 1;
560        }
561        if self.consumed_rows != 0 {
562            len += 1;
563        }
564        if self.pending_epoch_lag != 0 {
565            len += 1;
566        }
567        let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.CreateMviewProgress", len)?;
568        if self.backfill_actor_id != 0 {
569            struct_ser.serialize_field("backfillActorId", &self.backfill_actor_id)?;
570        }
571        if self.done {
572            struct_ser.serialize_field("done", &self.done)?;
573        }
574        if self.consumed_epoch != 0 {
575            #[allow(clippy::needless_borrow)]
576            #[allow(clippy::needless_borrows_for_generic_args)]
577            struct_ser.serialize_field("consumedEpoch", ToString::to_string(&self.consumed_epoch).as_str())?;
578        }
579        if self.consumed_rows != 0 {
580            #[allow(clippy::needless_borrow)]
581            #[allow(clippy::needless_borrows_for_generic_args)]
582            struct_ser.serialize_field("consumedRows", ToString::to_string(&self.consumed_rows).as_str())?;
583        }
584        if self.pending_epoch_lag != 0 {
585            #[allow(clippy::needless_borrow)]
586            #[allow(clippy::needless_borrows_for_generic_args)]
587            struct_ser.serialize_field("pendingEpochLag", ToString::to_string(&self.pending_epoch_lag).as_str())?;
588        }
589        struct_ser.end()
590    }
591}
592impl<'de> serde::Deserialize<'de> for barrier_complete_response::CreateMviewProgress {
593    #[allow(deprecated)]
594    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
595    where
596        D: serde::Deserializer<'de>,
597    {
598        const FIELDS: &[&str] = &[
599            "backfill_actor_id",
600            "backfillActorId",
601            "done",
602            "consumed_epoch",
603            "consumedEpoch",
604            "consumed_rows",
605            "consumedRows",
606            "pending_epoch_lag",
607            "pendingEpochLag",
608        ];
609
610        #[allow(clippy::enum_variant_names)]
611        enum GeneratedField {
612            BackfillActorId,
613            Done,
614            ConsumedEpoch,
615            ConsumedRows,
616            PendingEpochLag,
617        }
618        impl<'de> serde::Deserialize<'de> for GeneratedField {
619            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
620            where
621                D: serde::Deserializer<'de>,
622            {
623                struct GeneratedVisitor;
624
625                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
626                    type Value = GeneratedField;
627
628                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
629                        write!(formatter, "expected one of: {:?}", &FIELDS)
630                    }
631
632                    #[allow(unused_variables)]
633                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
634                    where
635                        E: serde::de::Error,
636                    {
637                        match value {
638                            "backfillActorId" | "backfill_actor_id" => Ok(GeneratedField::BackfillActorId),
639                            "done" => Ok(GeneratedField::Done),
640                            "consumedEpoch" | "consumed_epoch" => Ok(GeneratedField::ConsumedEpoch),
641                            "consumedRows" | "consumed_rows" => Ok(GeneratedField::ConsumedRows),
642                            "pendingEpochLag" | "pending_epoch_lag" => Ok(GeneratedField::PendingEpochLag),
643                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
644                        }
645                    }
646                }
647                deserializer.deserialize_identifier(GeneratedVisitor)
648            }
649        }
650        struct GeneratedVisitor;
651        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
652            type Value = barrier_complete_response::CreateMviewProgress;
653
654            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
655                formatter.write_str("struct stream_service.BarrierCompleteResponse.CreateMviewProgress")
656            }
657
658            fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::CreateMviewProgress, V::Error>
659                where
660                    V: serde::de::MapAccess<'de>,
661            {
662                let mut backfill_actor_id__ = None;
663                let mut done__ = None;
664                let mut consumed_epoch__ = None;
665                let mut consumed_rows__ = None;
666                let mut pending_epoch_lag__ = None;
667                while let Some(k) = map_.next_key()? {
668                    match k {
669                        GeneratedField::BackfillActorId => {
670                            if backfill_actor_id__.is_some() {
671                                return Err(serde::de::Error::duplicate_field("backfillActorId"));
672                            }
673                            backfill_actor_id__ = 
674                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
675                            ;
676                        }
677                        GeneratedField::Done => {
678                            if done__.is_some() {
679                                return Err(serde::de::Error::duplicate_field("done"));
680                            }
681                            done__ = Some(map_.next_value()?);
682                        }
683                        GeneratedField::ConsumedEpoch => {
684                            if consumed_epoch__.is_some() {
685                                return Err(serde::de::Error::duplicate_field("consumedEpoch"));
686                            }
687                            consumed_epoch__ = 
688                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
689                            ;
690                        }
691                        GeneratedField::ConsumedRows => {
692                            if consumed_rows__.is_some() {
693                                return Err(serde::de::Error::duplicate_field("consumedRows"));
694                            }
695                            consumed_rows__ = 
696                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
697                            ;
698                        }
699                        GeneratedField::PendingEpochLag => {
700                            if pending_epoch_lag__.is_some() {
701                                return Err(serde::de::Error::duplicate_field("pendingEpochLag"));
702                            }
703                            pending_epoch_lag__ = 
704                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
705                            ;
706                        }
707                    }
708                }
709                Ok(barrier_complete_response::CreateMviewProgress {
710                    backfill_actor_id: backfill_actor_id__.unwrap_or_default(),
711                    done: done__.unwrap_or_default(),
712                    consumed_epoch: consumed_epoch__.unwrap_or_default(),
713                    consumed_rows: consumed_rows__.unwrap_or_default(),
714                    pending_epoch_lag: pending_epoch_lag__.unwrap_or_default(),
715                })
716            }
717        }
718        deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.CreateMviewProgress", FIELDS, GeneratedVisitor)
719    }
720}
721impl serde::Serialize for barrier_complete_response::LocalSstableInfo {
722    #[allow(deprecated)]
723    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
724    where
725        S: serde::Serializer,
726    {
727        use serde::ser::SerializeStruct;
728        let mut len = 0;
729        if self.sst.is_some() {
730            len += 1;
731        }
732        if !self.table_stats_map.is_empty() {
733            len += 1;
734        }
735        if self.created_at != 0 {
736            len += 1;
737        }
738        let mut struct_ser = serializer.serialize_struct("stream_service.BarrierCompleteResponse.LocalSstableInfo", len)?;
739        if let Some(v) = self.sst.as_ref() {
740            struct_ser.serialize_field("sst", v)?;
741        }
742        if !self.table_stats_map.is_empty() {
743            struct_ser.serialize_field("tableStatsMap", &self.table_stats_map)?;
744        }
745        if self.created_at != 0 {
746            #[allow(clippy::needless_borrow)]
747            #[allow(clippy::needless_borrows_for_generic_args)]
748            struct_ser.serialize_field("createdAt", ToString::to_string(&self.created_at).as_str())?;
749        }
750        struct_ser.end()
751    }
752}
753impl<'de> serde::Deserialize<'de> for barrier_complete_response::LocalSstableInfo {
754    #[allow(deprecated)]
755    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
756    where
757        D: serde::Deserializer<'de>,
758    {
759        const FIELDS: &[&str] = &[
760            "sst",
761            "table_stats_map",
762            "tableStatsMap",
763            "created_at",
764            "createdAt",
765        ];
766
767        #[allow(clippy::enum_variant_names)]
768        enum GeneratedField {
769            Sst,
770            TableStatsMap,
771            CreatedAt,
772        }
773        impl<'de> serde::Deserialize<'de> for GeneratedField {
774            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
775            where
776                D: serde::Deserializer<'de>,
777            {
778                struct GeneratedVisitor;
779
780                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
781                    type Value = GeneratedField;
782
783                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
784                        write!(formatter, "expected one of: {:?}", &FIELDS)
785                    }
786
787                    #[allow(unused_variables)]
788                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
789                    where
790                        E: serde::de::Error,
791                    {
792                        match value {
793                            "sst" => Ok(GeneratedField::Sst),
794                            "tableStatsMap" | "table_stats_map" => Ok(GeneratedField::TableStatsMap),
795                            "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
796                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
797                        }
798                    }
799                }
800                deserializer.deserialize_identifier(GeneratedVisitor)
801            }
802        }
803        struct GeneratedVisitor;
804        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
805            type Value = barrier_complete_response::LocalSstableInfo;
806
807            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
808                formatter.write_str("struct stream_service.BarrierCompleteResponse.LocalSstableInfo")
809            }
810
811            fn visit_map<V>(self, mut map_: V) -> std::result::Result<barrier_complete_response::LocalSstableInfo, V::Error>
812                where
813                    V: serde::de::MapAccess<'de>,
814            {
815                let mut sst__ = None;
816                let mut table_stats_map__ = None;
817                let mut created_at__ = None;
818                while let Some(k) = map_.next_key()? {
819                    match k {
820                        GeneratedField::Sst => {
821                            if sst__.is_some() {
822                                return Err(serde::de::Error::duplicate_field("sst"));
823                            }
824                            sst__ = map_.next_value()?;
825                        }
826                        GeneratedField::TableStatsMap => {
827                            if table_stats_map__.is_some() {
828                                return Err(serde::de::Error::duplicate_field("tableStatsMap"));
829                            }
830                            table_stats_map__ = Some(
831                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
832                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
833                            );
834                        }
835                        GeneratedField::CreatedAt => {
836                            if created_at__.is_some() {
837                                return Err(serde::de::Error::duplicate_field("createdAt"));
838                            }
839                            created_at__ = 
840                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
841                            ;
842                        }
843                    }
844                }
845                Ok(barrier_complete_response::LocalSstableInfo {
846                    sst: sst__,
847                    table_stats_map: table_stats_map__.unwrap_or_default(),
848                    created_at: created_at__.unwrap_or_default(),
849                })
850            }
851        }
852        deserializer.deserialize_struct("stream_service.BarrierCompleteResponse.LocalSstableInfo", FIELDS, GeneratedVisitor)
853    }
854}
855impl serde::Serialize for GetMinUncommittedObjectIdRequest {
856    #[allow(deprecated)]
857    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
858    where
859        S: serde::Serializer,
860    {
861        use serde::ser::SerializeStruct;
862        let len = 0;
863        let struct_ser = serializer.serialize_struct("stream_service.GetMinUncommittedObjectIdRequest", len)?;
864        struct_ser.end()
865    }
866}
867impl<'de> serde::Deserialize<'de> for GetMinUncommittedObjectIdRequest {
868    #[allow(deprecated)]
869    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
870    where
871        D: serde::Deserializer<'de>,
872    {
873        const FIELDS: &[&str] = &[
874        ];
875
876        #[allow(clippy::enum_variant_names)]
877        enum GeneratedField {
878        }
879        impl<'de> serde::Deserialize<'de> for GeneratedField {
880            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
881            where
882                D: serde::Deserializer<'de>,
883            {
884                struct GeneratedVisitor;
885
886                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
887                    type Value = GeneratedField;
888
889                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
890                        write!(formatter, "expected one of: {:?}", &FIELDS)
891                    }
892
893                    #[allow(unused_variables)]
894                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
895                    where
896                        E: serde::de::Error,
897                    {
898                            Err(serde::de::Error::unknown_field(value, FIELDS))
899                    }
900                }
901                deserializer.deserialize_identifier(GeneratedVisitor)
902            }
903        }
904        struct GeneratedVisitor;
905        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
906            type Value = GetMinUncommittedObjectIdRequest;
907
908            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
909                formatter.write_str("struct stream_service.GetMinUncommittedObjectIdRequest")
910            }
911
912            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMinUncommittedObjectIdRequest, V::Error>
913                where
914                    V: serde::de::MapAccess<'de>,
915            {
916                while map_.next_key::<GeneratedField>()?.is_some() {
917                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
918                }
919                Ok(GetMinUncommittedObjectIdRequest {
920                })
921            }
922        }
923        deserializer.deserialize_struct("stream_service.GetMinUncommittedObjectIdRequest", FIELDS, GeneratedVisitor)
924    }
925}
926impl serde::Serialize for GetMinUncommittedObjectIdResponse {
927    #[allow(deprecated)]
928    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
929    where
930        S: serde::Serializer,
931    {
932        use serde::ser::SerializeStruct;
933        let mut len = 0;
934        if self.min_uncommitted_object_id != 0 {
935            len += 1;
936        }
937        let mut struct_ser = serializer.serialize_struct("stream_service.GetMinUncommittedObjectIdResponse", len)?;
938        if self.min_uncommitted_object_id != 0 {
939            #[allow(clippy::needless_borrow)]
940            #[allow(clippy::needless_borrows_for_generic_args)]
941            struct_ser.serialize_field("minUncommittedObjectId", ToString::to_string(&self.min_uncommitted_object_id).as_str())?;
942        }
943        struct_ser.end()
944    }
945}
946impl<'de> serde::Deserialize<'de> for GetMinUncommittedObjectIdResponse {
947    #[allow(deprecated)]
948    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
949    where
950        D: serde::Deserializer<'de>,
951    {
952        const FIELDS: &[&str] = &[
953            "min_uncommitted_object_id",
954            "minUncommittedObjectId",
955        ];
956
957        #[allow(clippy::enum_variant_names)]
958        enum GeneratedField {
959            MinUncommittedObjectId,
960        }
961        impl<'de> serde::Deserialize<'de> for GeneratedField {
962            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
963            where
964                D: serde::Deserializer<'de>,
965            {
966                struct GeneratedVisitor;
967
968                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
969                    type Value = GeneratedField;
970
971                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
972                        write!(formatter, "expected one of: {:?}", &FIELDS)
973                    }
974
975                    #[allow(unused_variables)]
976                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
977                    where
978                        E: serde::de::Error,
979                    {
980                        match value {
981                            "minUncommittedObjectId" | "min_uncommitted_object_id" => Ok(GeneratedField::MinUncommittedObjectId),
982                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
983                        }
984                    }
985                }
986                deserializer.deserialize_identifier(GeneratedVisitor)
987            }
988        }
989        struct GeneratedVisitor;
990        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
991            type Value = GetMinUncommittedObjectIdResponse;
992
993            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
994                formatter.write_str("struct stream_service.GetMinUncommittedObjectIdResponse")
995            }
996
997            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMinUncommittedObjectIdResponse, V::Error>
998                where
999                    V: serde::de::MapAccess<'de>,
1000            {
1001                let mut min_uncommitted_object_id__ = None;
1002                while let Some(k) = map_.next_key()? {
1003                    match k {
1004                        GeneratedField::MinUncommittedObjectId => {
1005                            if min_uncommitted_object_id__.is_some() {
1006                                return Err(serde::de::Error::duplicate_field("minUncommittedObjectId"));
1007                            }
1008                            min_uncommitted_object_id__ = 
1009                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1010                            ;
1011                        }
1012                    }
1013                }
1014                Ok(GetMinUncommittedObjectIdResponse {
1015                    min_uncommitted_object_id: min_uncommitted_object_id__.unwrap_or_default(),
1016                })
1017            }
1018        }
1019        deserializer.deserialize_struct("stream_service.GetMinUncommittedObjectIdResponse", FIELDS, GeneratedVisitor)
1020    }
1021}
1022impl serde::Serialize for InjectBarrierRequest {
1023    #[allow(deprecated)]
1024    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1025    where
1026        S: serde::Serializer,
1027    {
1028        use serde::ser::SerializeStruct;
1029        let mut len = 0;
1030        if !self.request_id.is_empty() {
1031            len += 1;
1032        }
1033        if self.barrier.is_some() {
1034            len += 1;
1035        }
1036        if self.database_id != 0 {
1037            len += 1;
1038        }
1039        if !self.actor_ids_to_collect.is_empty() {
1040            len += 1;
1041        }
1042        if !self.table_ids_to_sync.is_empty() {
1043            len += 1;
1044        }
1045        if self.partial_graph_id != 0 {
1046            len += 1;
1047        }
1048        if !self.actors_to_build.is_empty() {
1049            len += 1;
1050        }
1051        if !self.subscriptions_to_add.is_empty() {
1052            len += 1;
1053        }
1054        if !self.subscriptions_to_remove.is_empty() {
1055            len += 1;
1056        }
1057        let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest", len)?;
1058        if !self.request_id.is_empty() {
1059            struct_ser.serialize_field("requestId", &self.request_id)?;
1060        }
1061        if let Some(v) = self.barrier.as_ref() {
1062            struct_ser.serialize_field("barrier", v)?;
1063        }
1064        if self.database_id != 0 {
1065            struct_ser.serialize_field("databaseId", &self.database_id)?;
1066        }
1067        if !self.actor_ids_to_collect.is_empty() {
1068            struct_ser.serialize_field("actorIdsToCollect", &self.actor_ids_to_collect)?;
1069        }
1070        if !self.table_ids_to_sync.is_empty() {
1071            struct_ser.serialize_field("tableIdsToSync", &self.table_ids_to_sync)?;
1072        }
1073        if self.partial_graph_id != 0 {
1074            struct_ser.serialize_field("partialGraphId", &self.partial_graph_id)?;
1075        }
1076        if !self.actors_to_build.is_empty() {
1077            struct_ser.serialize_field("actorsToBuild", &self.actors_to_build)?;
1078        }
1079        if !self.subscriptions_to_add.is_empty() {
1080            struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
1081        }
1082        if !self.subscriptions_to_remove.is_empty() {
1083            struct_ser.serialize_field("subscriptionsToRemove", &self.subscriptions_to_remove)?;
1084        }
1085        struct_ser.end()
1086    }
1087}
1088impl<'de> serde::Deserialize<'de> for InjectBarrierRequest {
1089    #[allow(deprecated)]
1090    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1091    where
1092        D: serde::Deserializer<'de>,
1093    {
1094        const FIELDS: &[&str] = &[
1095            "request_id",
1096            "requestId",
1097            "barrier",
1098            "database_id",
1099            "databaseId",
1100            "actor_ids_to_collect",
1101            "actorIdsToCollect",
1102            "table_ids_to_sync",
1103            "tableIdsToSync",
1104            "partial_graph_id",
1105            "partialGraphId",
1106            "actors_to_build",
1107            "actorsToBuild",
1108            "subscriptions_to_add",
1109            "subscriptionsToAdd",
1110            "subscriptions_to_remove",
1111            "subscriptionsToRemove",
1112        ];
1113
1114        #[allow(clippy::enum_variant_names)]
1115        enum GeneratedField {
1116            RequestId,
1117            Barrier,
1118            DatabaseId,
1119            ActorIdsToCollect,
1120            TableIdsToSync,
1121            PartialGraphId,
1122            ActorsToBuild,
1123            SubscriptionsToAdd,
1124            SubscriptionsToRemove,
1125        }
1126        impl<'de> serde::Deserialize<'de> for GeneratedField {
1127            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1128            where
1129                D: serde::Deserializer<'de>,
1130            {
1131                struct GeneratedVisitor;
1132
1133                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1134                    type Value = GeneratedField;
1135
1136                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1137                        write!(formatter, "expected one of: {:?}", &FIELDS)
1138                    }
1139
1140                    #[allow(unused_variables)]
1141                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1142                    where
1143                        E: serde::de::Error,
1144                    {
1145                        match value {
1146                            "requestId" | "request_id" => Ok(GeneratedField::RequestId),
1147                            "barrier" => Ok(GeneratedField::Barrier),
1148                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1149                            "actorIdsToCollect" | "actor_ids_to_collect" => Ok(GeneratedField::ActorIdsToCollect),
1150                            "tableIdsToSync" | "table_ids_to_sync" => Ok(GeneratedField::TableIdsToSync),
1151                            "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
1152                            "actorsToBuild" | "actors_to_build" => Ok(GeneratedField::ActorsToBuild),
1153                            "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
1154                            "subscriptionsToRemove" | "subscriptions_to_remove" => Ok(GeneratedField::SubscriptionsToRemove),
1155                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1156                        }
1157                    }
1158                }
1159                deserializer.deserialize_identifier(GeneratedVisitor)
1160            }
1161        }
1162        struct GeneratedVisitor;
1163        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1164            type Value = InjectBarrierRequest;
1165
1166            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1167                formatter.write_str("struct stream_service.InjectBarrierRequest")
1168            }
1169
1170            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectBarrierRequest, V::Error>
1171                where
1172                    V: serde::de::MapAccess<'de>,
1173            {
1174                let mut request_id__ = None;
1175                let mut barrier__ = None;
1176                let mut database_id__ = None;
1177                let mut actor_ids_to_collect__ = None;
1178                let mut table_ids_to_sync__ = None;
1179                let mut partial_graph_id__ = None;
1180                let mut actors_to_build__ = None;
1181                let mut subscriptions_to_add__ = None;
1182                let mut subscriptions_to_remove__ = None;
1183                while let Some(k) = map_.next_key()? {
1184                    match k {
1185                        GeneratedField::RequestId => {
1186                            if request_id__.is_some() {
1187                                return Err(serde::de::Error::duplicate_field("requestId"));
1188                            }
1189                            request_id__ = Some(map_.next_value()?);
1190                        }
1191                        GeneratedField::Barrier => {
1192                            if barrier__.is_some() {
1193                                return Err(serde::de::Error::duplicate_field("barrier"));
1194                            }
1195                            barrier__ = map_.next_value()?;
1196                        }
1197                        GeneratedField::DatabaseId => {
1198                            if database_id__.is_some() {
1199                                return Err(serde::de::Error::duplicate_field("databaseId"));
1200                            }
1201                            database_id__ = 
1202                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1203                            ;
1204                        }
1205                        GeneratedField::ActorIdsToCollect => {
1206                            if actor_ids_to_collect__.is_some() {
1207                                return Err(serde::de::Error::duplicate_field("actorIdsToCollect"));
1208                            }
1209                            actor_ids_to_collect__ = 
1210                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1211                                    .into_iter().map(|x| x.0).collect())
1212                            ;
1213                        }
1214                        GeneratedField::TableIdsToSync => {
1215                            if table_ids_to_sync__.is_some() {
1216                                return Err(serde::de::Error::duplicate_field("tableIdsToSync"));
1217                            }
1218                            table_ids_to_sync__ = 
1219                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1220                                    .into_iter().map(|x| x.0).collect())
1221                            ;
1222                        }
1223                        GeneratedField::PartialGraphId => {
1224                            if partial_graph_id__.is_some() {
1225                                return Err(serde::de::Error::duplicate_field("partialGraphId"));
1226                            }
1227                            partial_graph_id__ = 
1228                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1229                            ;
1230                        }
1231                        GeneratedField::ActorsToBuild => {
1232                            if actors_to_build__.is_some() {
1233                                return Err(serde::de::Error::duplicate_field("actorsToBuild"));
1234                            }
1235                            actors_to_build__ = Some(map_.next_value()?);
1236                        }
1237                        GeneratedField::SubscriptionsToAdd => {
1238                            if subscriptions_to_add__.is_some() {
1239                                return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
1240                            }
1241                            subscriptions_to_add__ = Some(map_.next_value()?);
1242                        }
1243                        GeneratedField::SubscriptionsToRemove => {
1244                            if subscriptions_to_remove__.is_some() {
1245                                return Err(serde::de::Error::duplicate_field("subscriptionsToRemove"));
1246                            }
1247                            subscriptions_to_remove__ = Some(map_.next_value()?);
1248                        }
1249                    }
1250                }
1251                Ok(InjectBarrierRequest {
1252                    request_id: request_id__.unwrap_or_default(),
1253                    barrier: barrier__,
1254                    database_id: database_id__.unwrap_or_default(),
1255                    actor_ids_to_collect: actor_ids_to_collect__.unwrap_or_default(),
1256                    table_ids_to_sync: table_ids_to_sync__.unwrap_or_default(),
1257                    partial_graph_id: partial_graph_id__.unwrap_or_default(),
1258                    actors_to_build: actors_to_build__.unwrap_or_default(),
1259                    subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
1260                    subscriptions_to_remove: subscriptions_to_remove__.unwrap_or_default(),
1261                })
1262            }
1263        }
1264        deserializer.deserialize_struct("stream_service.InjectBarrierRequest", FIELDS, GeneratedVisitor)
1265    }
1266}
1267impl serde::Serialize for inject_barrier_request::BuildActorInfo {
1268    #[allow(deprecated)]
1269    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1270    where
1271        S: serde::Serializer,
1272    {
1273        use serde::ser::SerializeStruct;
1274        let mut len = 0;
1275        if self.actor_id != 0 {
1276            len += 1;
1277        }
1278        if !self.fragment_upstreams.is_empty() {
1279            len += 1;
1280        }
1281        if !self.dispatchers.is_empty() {
1282            len += 1;
1283        }
1284        if self.vnode_bitmap.is_some() {
1285            len += 1;
1286        }
1287        if !self.mview_definition.is_empty() {
1288            len += 1;
1289        }
1290        if self.expr_context.is_some() {
1291            len += 1;
1292        }
1293        let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo", len)?;
1294        if self.actor_id != 0 {
1295            struct_ser.serialize_field("actorId", &self.actor_id)?;
1296        }
1297        if !self.fragment_upstreams.is_empty() {
1298            struct_ser.serialize_field("fragmentUpstreams", &self.fragment_upstreams)?;
1299        }
1300        if !self.dispatchers.is_empty() {
1301            struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
1302        }
1303        if let Some(v) = self.vnode_bitmap.as_ref() {
1304            struct_ser.serialize_field("vnodeBitmap", v)?;
1305        }
1306        if !self.mview_definition.is_empty() {
1307            struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
1308        }
1309        if let Some(v) = self.expr_context.as_ref() {
1310            struct_ser.serialize_field("exprContext", v)?;
1311        }
1312        struct_ser.end()
1313    }
1314}
1315impl<'de> serde::Deserialize<'de> for inject_barrier_request::BuildActorInfo {
1316    #[allow(deprecated)]
1317    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1318    where
1319        D: serde::Deserializer<'de>,
1320    {
1321        const FIELDS: &[&str] = &[
1322            "actor_id",
1323            "actorId",
1324            "fragment_upstreams",
1325            "fragmentUpstreams",
1326            "dispatchers",
1327            "vnode_bitmap",
1328            "vnodeBitmap",
1329            "mview_definition",
1330            "mviewDefinition",
1331            "expr_context",
1332            "exprContext",
1333        ];
1334
1335        #[allow(clippy::enum_variant_names)]
1336        enum GeneratedField {
1337            ActorId,
1338            FragmentUpstreams,
1339            Dispatchers,
1340            VnodeBitmap,
1341            MviewDefinition,
1342            ExprContext,
1343        }
1344        impl<'de> serde::Deserialize<'de> for GeneratedField {
1345            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1346            where
1347                D: serde::Deserializer<'de>,
1348            {
1349                struct GeneratedVisitor;
1350
1351                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1352                    type Value = GeneratedField;
1353
1354                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1355                        write!(formatter, "expected one of: {:?}", &FIELDS)
1356                    }
1357
1358                    #[allow(unused_variables)]
1359                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1360                    where
1361                        E: serde::de::Error,
1362                    {
1363                        match value {
1364                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
1365                            "fragmentUpstreams" | "fragment_upstreams" => Ok(GeneratedField::FragmentUpstreams),
1366                            "dispatchers" => Ok(GeneratedField::Dispatchers),
1367                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
1368                            "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
1369                            "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
1370                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1371                        }
1372                    }
1373                }
1374                deserializer.deserialize_identifier(GeneratedVisitor)
1375            }
1376        }
1377        struct GeneratedVisitor;
1378        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1379            type Value = inject_barrier_request::BuildActorInfo;
1380
1381            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1382                formatter.write_str("struct stream_service.InjectBarrierRequest.BuildActorInfo")
1383            }
1384
1385            fn visit_map<V>(self, mut map_: V) -> std::result::Result<inject_barrier_request::BuildActorInfo, V::Error>
1386                where
1387                    V: serde::de::MapAccess<'de>,
1388            {
1389                let mut actor_id__ = None;
1390                let mut fragment_upstreams__ = None;
1391                let mut dispatchers__ = None;
1392                let mut vnode_bitmap__ = None;
1393                let mut mview_definition__ = None;
1394                let mut expr_context__ = None;
1395                while let Some(k) = map_.next_key()? {
1396                    match k {
1397                        GeneratedField::ActorId => {
1398                            if actor_id__.is_some() {
1399                                return Err(serde::de::Error::duplicate_field("actorId"));
1400                            }
1401                            actor_id__ = 
1402                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1403                            ;
1404                        }
1405                        GeneratedField::FragmentUpstreams => {
1406                            if fragment_upstreams__.is_some() {
1407                                return Err(serde::de::Error::duplicate_field("fragmentUpstreams"));
1408                            }
1409                            fragment_upstreams__ = Some(
1410                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1411                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1412                            );
1413                        }
1414                        GeneratedField::Dispatchers => {
1415                            if dispatchers__.is_some() {
1416                                return Err(serde::de::Error::duplicate_field("dispatchers"));
1417                            }
1418                            dispatchers__ = Some(map_.next_value()?);
1419                        }
1420                        GeneratedField::VnodeBitmap => {
1421                            if vnode_bitmap__.is_some() {
1422                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
1423                            }
1424                            vnode_bitmap__ = map_.next_value()?;
1425                        }
1426                        GeneratedField::MviewDefinition => {
1427                            if mview_definition__.is_some() {
1428                                return Err(serde::de::Error::duplicate_field("mviewDefinition"));
1429                            }
1430                            mview_definition__ = Some(map_.next_value()?);
1431                        }
1432                        GeneratedField::ExprContext => {
1433                            if expr_context__.is_some() {
1434                                return Err(serde::de::Error::duplicate_field("exprContext"));
1435                            }
1436                            expr_context__ = map_.next_value()?;
1437                        }
1438                    }
1439                }
1440                Ok(inject_barrier_request::BuildActorInfo {
1441                    actor_id: actor_id__.unwrap_or_default(),
1442                    fragment_upstreams: fragment_upstreams__.unwrap_or_default(),
1443                    dispatchers: dispatchers__.unwrap_or_default(),
1444                    vnode_bitmap: vnode_bitmap__,
1445                    mview_definition: mview_definition__.unwrap_or_default(),
1446                    expr_context: expr_context__,
1447                })
1448            }
1449        }
1450        deserializer.deserialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo", FIELDS, GeneratedVisitor)
1451    }
1452}
1453impl serde::Serialize for inject_barrier_request::build_actor_info::UpstreamActors {
1454    #[allow(deprecated)]
1455    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1456    where
1457        S: serde::Serializer,
1458    {
1459        use serde::ser::SerializeStruct;
1460        let mut len = 0;
1461        if !self.actors.is_empty() {
1462            len += 1;
1463        }
1464        let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo.UpstreamActors", len)?;
1465        if !self.actors.is_empty() {
1466            struct_ser.serialize_field("actors", &self.actors)?;
1467        }
1468        struct_ser.end()
1469    }
1470}
1471impl<'de> serde::Deserialize<'de> for inject_barrier_request::build_actor_info::UpstreamActors {
1472    #[allow(deprecated)]
1473    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1474    where
1475        D: serde::Deserializer<'de>,
1476    {
1477        const FIELDS: &[&str] = &[
1478            "actors",
1479        ];
1480
1481        #[allow(clippy::enum_variant_names)]
1482        enum GeneratedField {
1483            Actors,
1484        }
1485        impl<'de> serde::Deserialize<'de> for GeneratedField {
1486            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1487            where
1488                D: serde::Deserializer<'de>,
1489            {
1490                struct GeneratedVisitor;
1491
1492                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1493                    type Value = GeneratedField;
1494
1495                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1496                        write!(formatter, "expected one of: {:?}", &FIELDS)
1497                    }
1498
1499                    #[allow(unused_variables)]
1500                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1501                    where
1502                        E: serde::de::Error,
1503                    {
1504                        match value {
1505                            "actors" => Ok(GeneratedField::Actors),
1506                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1507                        }
1508                    }
1509                }
1510                deserializer.deserialize_identifier(GeneratedVisitor)
1511            }
1512        }
1513        struct GeneratedVisitor;
1514        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1515            type Value = inject_barrier_request::build_actor_info::UpstreamActors;
1516
1517            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1518                formatter.write_str("struct stream_service.InjectBarrierRequest.BuildActorInfo.UpstreamActors")
1519            }
1520
1521            fn visit_map<V>(self, mut map_: V) -> std::result::Result<inject_barrier_request::build_actor_info::UpstreamActors, V::Error>
1522                where
1523                    V: serde::de::MapAccess<'de>,
1524            {
1525                let mut actors__ = None;
1526                while let Some(k) = map_.next_key()? {
1527                    match k {
1528                        GeneratedField::Actors => {
1529                            if actors__.is_some() {
1530                                return Err(serde::de::Error::duplicate_field("actors"));
1531                            }
1532                            actors__ = Some(map_.next_value()?);
1533                        }
1534                    }
1535                }
1536                Ok(inject_barrier_request::build_actor_info::UpstreamActors {
1537                    actors: actors__.unwrap_or_default(),
1538                })
1539            }
1540        }
1541        deserializer.deserialize_struct("stream_service.InjectBarrierRequest.BuildActorInfo.UpstreamActors", FIELDS, GeneratedVisitor)
1542    }
1543}
1544impl serde::Serialize for inject_barrier_request::FragmentBuildActorInfo {
1545    #[allow(deprecated)]
1546    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1547    where
1548        S: serde::Serializer,
1549    {
1550        use serde::ser::SerializeStruct;
1551        let mut len = 0;
1552        if self.fragment_id != 0 {
1553            len += 1;
1554        }
1555        if self.node.is_some() {
1556            len += 1;
1557        }
1558        if !self.actors.is_empty() {
1559            len += 1;
1560        }
1561        let mut struct_ser = serializer.serialize_struct("stream_service.InjectBarrierRequest.FragmentBuildActorInfo", len)?;
1562        if self.fragment_id != 0 {
1563            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
1564        }
1565        if let Some(v) = self.node.as_ref() {
1566            struct_ser.serialize_field("node", v)?;
1567        }
1568        if !self.actors.is_empty() {
1569            struct_ser.serialize_field("actors", &self.actors)?;
1570        }
1571        struct_ser.end()
1572    }
1573}
1574impl<'de> serde::Deserialize<'de> for inject_barrier_request::FragmentBuildActorInfo {
1575    #[allow(deprecated)]
1576    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1577    where
1578        D: serde::Deserializer<'de>,
1579    {
1580        const FIELDS: &[&str] = &[
1581            "fragment_id",
1582            "fragmentId",
1583            "node",
1584            "actors",
1585        ];
1586
1587        #[allow(clippy::enum_variant_names)]
1588        enum GeneratedField {
1589            FragmentId,
1590            Node,
1591            Actors,
1592        }
1593        impl<'de> serde::Deserialize<'de> for GeneratedField {
1594            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1595            where
1596                D: serde::Deserializer<'de>,
1597            {
1598                struct GeneratedVisitor;
1599
1600                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1601                    type Value = GeneratedField;
1602
1603                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1604                        write!(formatter, "expected one of: {:?}", &FIELDS)
1605                    }
1606
1607                    #[allow(unused_variables)]
1608                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1609                    where
1610                        E: serde::de::Error,
1611                    {
1612                        match value {
1613                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
1614                            "node" => Ok(GeneratedField::Node),
1615                            "actors" => Ok(GeneratedField::Actors),
1616                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1617                        }
1618                    }
1619                }
1620                deserializer.deserialize_identifier(GeneratedVisitor)
1621            }
1622        }
1623        struct GeneratedVisitor;
1624        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1625            type Value = inject_barrier_request::FragmentBuildActorInfo;
1626
1627            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1628                formatter.write_str("struct stream_service.InjectBarrierRequest.FragmentBuildActorInfo")
1629            }
1630
1631            fn visit_map<V>(self, mut map_: V) -> std::result::Result<inject_barrier_request::FragmentBuildActorInfo, V::Error>
1632                where
1633                    V: serde::de::MapAccess<'de>,
1634            {
1635                let mut fragment_id__ = None;
1636                let mut node__ = None;
1637                let mut actors__ = None;
1638                while let Some(k) = map_.next_key()? {
1639                    match k {
1640                        GeneratedField::FragmentId => {
1641                            if fragment_id__.is_some() {
1642                                return Err(serde::de::Error::duplicate_field("fragmentId"));
1643                            }
1644                            fragment_id__ = 
1645                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1646                            ;
1647                        }
1648                        GeneratedField::Node => {
1649                            if node__.is_some() {
1650                                return Err(serde::de::Error::duplicate_field("node"));
1651                            }
1652                            node__ = map_.next_value()?;
1653                        }
1654                        GeneratedField::Actors => {
1655                            if actors__.is_some() {
1656                                return Err(serde::de::Error::duplicate_field("actors"));
1657                            }
1658                            actors__ = Some(map_.next_value()?);
1659                        }
1660                    }
1661                }
1662                Ok(inject_barrier_request::FragmentBuildActorInfo {
1663                    fragment_id: fragment_id__.unwrap_or_default(),
1664                    node: node__,
1665                    actors: actors__.unwrap_or_default(),
1666                })
1667            }
1668        }
1669        deserializer.deserialize_struct("stream_service.InjectBarrierRequest.FragmentBuildActorInfo", FIELDS, GeneratedVisitor)
1670    }
1671}
1672impl serde::Serialize for ScoredError {
1673    #[allow(deprecated)]
1674    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1675    where
1676        S: serde::Serializer,
1677    {
1678        use serde::ser::SerializeStruct;
1679        let mut len = 0;
1680        if !self.err_msg.is_empty() {
1681            len += 1;
1682        }
1683        if self.score != 0 {
1684            len += 1;
1685        }
1686        let mut struct_ser = serializer.serialize_struct("stream_service.ScoredError", len)?;
1687        if !self.err_msg.is_empty() {
1688            struct_ser.serialize_field("errMsg", &self.err_msg)?;
1689        }
1690        if self.score != 0 {
1691            struct_ser.serialize_field("score", &self.score)?;
1692        }
1693        struct_ser.end()
1694    }
1695}
1696impl<'de> serde::Deserialize<'de> for ScoredError {
1697    #[allow(deprecated)]
1698    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1699    where
1700        D: serde::Deserializer<'de>,
1701    {
1702        const FIELDS: &[&str] = &[
1703            "err_msg",
1704            "errMsg",
1705            "score",
1706        ];
1707
1708        #[allow(clippy::enum_variant_names)]
1709        enum GeneratedField {
1710            ErrMsg,
1711            Score,
1712        }
1713        impl<'de> serde::Deserialize<'de> for GeneratedField {
1714            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1715            where
1716                D: serde::Deserializer<'de>,
1717            {
1718                struct GeneratedVisitor;
1719
1720                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1721                    type Value = GeneratedField;
1722
1723                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1724                        write!(formatter, "expected one of: {:?}", &FIELDS)
1725                    }
1726
1727                    #[allow(unused_variables)]
1728                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1729                    where
1730                        E: serde::de::Error,
1731                    {
1732                        match value {
1733                            "errMsg" | "err_msg" => Ok(GeneratedField::ErrMsg),
1734                            "score" => Ok(GeneratedField::Score),
1735                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1736                        }
1737                    }
1738                }
1739                deserializer.deserialize_identifier(GeneratedVisitor)
1740            }
1741        }
1742        struct GeneratedVisitor;
1743        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1744            type Value = ScoredError;
1745
1746            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1747                formatter.write_str("struct stream_service.ScoredError")
1748            }
1749
1750            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScoredError, V::Error>
1751                where
1752                    V: serde::de::MapAccess<'de>,
1753            {
1754                let mut err_msg__ = None;
1755                let mut score__ = None;
1756                while let Some(k) = map_.next_key()? {
1757                    match k {
1758                        GeneratedField::ErrMsg => {
1759                            if err_msg__.is_some() {
1760                                return Err(serde::de::Error::duplicate_field("errMsg"));
1761                            }
1762                            err_msg__ = Some(map_.next_value()?);
1763                        }
1764                        GeneratedField::Score => {
1765                            if score__.is_some() {
1766                                return Err(serde::de::Error::duplicate_field("score"));
1767                            }
1768                            score__ = 
1769                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1770                            ;
1771                        }
1772                    }
1773                }
1774                Ok(ScoredError {
1775                    err_msg: err_msg__.unwrap_or_default(),
1776                    score: score__.unwrap_or_default(),
1777                })
1778            }
1779        }
1780        deserializer.deserialize_struct("stream_service.ScoredError", FIELDS, GeneratedVisitor)
1781    }
1782}
1783impl serde::Serialize for StreamingControlStreamRequest {
1784    #[allow(deprecated)]
1785    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1786    where
1787        S: serde::Serializer,
1788    {
1789        use serde::ser::SerializeStruct;
1790        let mut len = 0;
1791        if self.request.is_some() {
1792            len += 1;
1793        }
1794        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest", len)?;
1795        if let Some(v) = self.request.as_ref() {
1796            match v {
1797                streaming_control_stream_request::Request::Init(v) => {
1798                    struct_ser.serialize_field("init", v)?;
1799                }
1800                streaming_control_stream_request::Request::InjectBarrier(v) => {
1801                    struct_ser.serialize_field("injectBarrier", v)?;
1802                }
1803                streaming_control_stream_request::Request::RemovePartialGraph(v) => {
1804                    struct_ser.serialize_field("removePartialGraph", v)?;
1805                }
1806                streaming_control_stream_request::Request::CreatePartialGraph(v) => {
1807                    struct_ser.serialize_field("createPartialGraph", v)?;
1808                }
1809                streaming_control_stream_request::Request::ResetDatabase(v) => {
1810                    struct_ser.serialize_field("resetDatabase", v)?;
1811                }
1812            }
1813        }
1814        struct_ser.end()
1815    }
1816}
1817impl<'de> serde::Deserialize<'de> for StreamingControlStreamRequest {
1818    #[allow(deprecated)]
1819    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1820    where
1821        D: serde::Deserializer<'de>,
1822    {
1823        const FIELDS: &[&str] = &[
1824            "init",
1825            "inject_barrier",
1826            "injectBarrier",
1827            "remove_partial_graph",
1828            "removePartialGraph",
1829            "create_partial_graph",
1830            "createPartialGraph",
1831            "reset_database",
1832            "resetDatabase",
1833        ];
1834
1835        #[allow(clippy::enum_variant_names)]
1836        enum GeneratedField {
1837            Init,
1838            InjectBarrier,
1839            RemovePartialGraph,
1840            CreatePartialGraph,
1841            ResetDatabase,
1842        }
1843        impl<'de> serde::Deserialize<'de> for GeneratedField {
1844            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1845            where
1846                D: serde::Deserializer<'de>,
1847            {
1848                struct GeneratedVisitor;
1849
1850                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1851                    type Value = GeneratedField;
1852
1853                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1854                        write!(formatter, "expected one of: {:?}", &FIELDS)
1855                    }
1856
1857                    #[allow(unused_variables)]
1858                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1859                    where
1860                        E: serde::de::Error,
1861                    {
1862                        match value {
1863                            "init" => Ok(GeneratedField::Init),
1864                            "injectBarrier" | "inject_barrier" => Ok(GeneratedField::InjectBarrier),
1865                            "removePartialGraph" | "remove_partial_graph" => Ok(GeneratedField::RemovePartialGraph),
1866                            "createPartialGraph" | "create_partial_graph" => Ok(GeneratedField::CreatePartialGraph),
1867                            "resetDatabase" | "reset_database" => Ok(GeneratedField::ResetDatabase),
1868                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1869                        }
1870                    }
1871                }
1872                deserializer.deserialize_identifier(GeneratedVisitor)
1873            }
1874        }
1875        struct GeneratedVisitor;
1876        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1877            type Value = StreamingControlStreamRequest;
1878
1879            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1880                formatter.write_str("struct stream_service.StreamingControlStreamRequest")
1881            }
1882
1883            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingControlStreamRequest, V::Error>
1884                where
1885                    V: serde::de::MapAccess<'de>,
1886            {
1887                let mut request__ = None;
1888                while let Some(k) = map_.next_key()? {
1889                    match k {
1890                        GeneratedField::Init => {
1891                            if request__.is_some() {
1892                                return Err(serde::de::Error::duplicate_field("init"));
1893                            }
1894                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::Init)
1895;
1896                        }
1897                        GeneratedField::InjectBarrier => {
1898                            if request__.is_some() {
1899                                return Err(serde::de::Error::duplicate_field("injectBarrier"));
1900                            }
1901                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::InjectBarrier)
1902;
1903                        }
1904                        GeneratedField::RemovePartialGraph => {
1905                            if request__.is_some() {
1906                                return Err(serde::de::Error::duplicate_field("removePartialGraph"));
1907                            }
1908                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::RemovePartialGraph)
1909;
1910                        }
1911                        GeneratedField::CreatePartialGraph => {
1912                            if request__.is_some() {
1913                                return Err(serde::de::Error::duplicate_field("createPartialGraph"));
1914                            }
1915                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::CreatePartialGraph)
1916;
1917                        }
1918                        GeneratedField::ResetDatabase => {
1919                            if request__.is_some() {
1920                                return Err(serde::de::Error::duplicate_field("resetDatabase"));
1921                            }
1922                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_request::Request::ResetDatabase)
1923;
1924                        }
1925                    }
1926                }
1927                Ok(StreamingControlStreamRequest {
1928                    request: request__,
1929                })
1930            }
1931        }
1932        deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest", FIELDS, GeneratedVisitor)
1933    }
1934}
1935impl serde::Serialize for streaming_control_stream_request::CreatePartialGraphRequest {
1936    #[allow(deprecated)]
1937    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1938    where
1939        S: serde::Serializer,
1940    {
1941        use serde::ser::SerializeStruct;
1942        let mut len = 0;
1943        if self.partial_graph_id != 0 {
1944            len += 1;
1945        }
1946        if self.database_id != 0 {
1947            len += 1;
1948        }
1949        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.CreatePartialGraphRequest", len)?;
1950        if self.partial_graph_id != 0 {
1951            struct_ser.serialize_field("partialGraphId", &self.partial_graph_id)?;
1952        }
1953        if self.database_id != 0 {
1954            struct_ser.serialize_field("databaseId", &self.database_id)?;
1955        }
1956        struct_ser.end()
1957    }
1958}
1959impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::CreatePartialGraphRequest {
1960    #[allow(deprecated)]
1961    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1962    where
1963        D: serde::Deserializer<'de>,
1964    {
1965        const FIELDS: &[&str] = &[
1966            "partial_graph_id",
1967            "partialGraphId",
1968            "database_id",
1969            "databaseId",
1970        ];
1971
1972        #[allow(clippy::enum_variant_names)]
1973        enum GeneratedField {
1974            PartialGraphId,
1975            DatabaseId,
1976        }
1977        impl<'de> serde::Deserialize<'de> for GeneratedField {
1978            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1979            where
1980                D: serde::Deserializer<'de>,
1981            {
1982                struct GeneratedVisitor;
1983
1984                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1985                    type Value = GeneratedField;
1986
1987                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1988                        write!(formatter, "expected one of: {:?}", &FIELDS)
1989                    }
1990
1991                    #[allow(unused_variables)]
1992                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1993                    where
1994                        E: serde::de::Error,
1995                    {
1996                        match value {
1997                            "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
1998                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1999                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2000                        }
2001                    }
2002                }
2003                deserializer.deserialize_identifier(GeneratedVisitor)
2004            }
2005        }
2006        struct GeneratedVisitor;
2007        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2008            type Value = streaming_control_stream_request::CreatePartialGraphRequest;
2009
2010            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2011                formatter.write_str("struct stream_service.StreamingControlStreamRequest.CreatePartialGraphRequest")
2012            }
2013
2014            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::CreatePartialGraphRequest, V::Error>
2015                where
2016                    V: serde::de::MapAccess<'de>,
2017            {
2018                let mut partial_graph_id__ = None;
2019                let mut database_id__ = None;
2020                while let Some(k) = map_.next_key()? {
2021                    match k {
2022                        GeneratedField::PartialGraphId => {
2023                            if partial_graph_id__.is_some() {
2024                                return Err(serde::de::Error::duplicate_field("partialGraphId"));
2025                            }
2026                            partial_graph_id__ = 
2027                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2028                            ;
2029                        }
2030                        GeneratedField::DatabaseId => {
2031                            if database_id__.is_some() {
2032                                return Err(serde::de::Error::duplicate_field("databaseId"));
2033                            }
2034                            database_id__ = 
2035                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2036                            ;
2037                        }
2038                    }
2039                }
2040                Ok(streaming_control_stream_request::CreatePartialGraphRequest {
2041                    partial_graph_id: partial_graph_id__.unwrap_or_default(),
2042                    database_id: database_id__.unwrap_or_default(),
2043                })
2044            }
2045        }
2046        deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.CreatePartialGraphRequest", FIELDS, GeneratedVisitor)
2047    }
2048}
2049impl serde::Serialize for streaming_control_stream_request::DatabaseInitialPartialGraph {
2050    #[allow(deprecated)]
2051    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2052    where
2053        S: serde::Serializer,
2054    {
2055        use serde::ser::SerializeStruct;
2056        let mut len = 0;
2057        if self.database_id != 0 {
2058            len += 1;
2059        }
2060        if !self.graphs.is_empty() {
2061            len += 1;
2062        }
2063        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.DatabaseInitialPartialGraph", len)?;
2064        if self.database_id != 0 {
2065            struct_ser.serialize_field("databaseId", &self.database_id)?;
2066        }
2067        if !self.graphs.is_empty() {
2068            struct_ser.serialize_field("graphs", &self.graphs)?;
2069        }
2070        struct_ser.end()
2071    }
2072}
2073impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::DatabaseInitialPartialGraph {
2074    #[allow(deprecated)]
2075    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2076    where
2077        D: serde::Deserializer<'de>,
2078    {
2079        const FIELDS: &[&str] = &[
2080            "database_id",
2081            "databaseId",
2082            "graphs",
2083        ];
2084
2085        #[allow(clippy::enum_variant_names)]
2086        enum GeneratedField {
2087            DatabaseId,
2088            Graphs,
2089        }
2090        impl<'de> serde::Deserialize<'de> for GeneratedField {
2091            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2092            where
2093                D: serde::Deserializer<'de>,
2094            {
2095                struct GeneratedVisitor;
2096
2097                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2098                    type Value = GeneratedField;
2099
2100                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2101                        write!(formatter, "expected one of: {:?}", &FIELDS)
2102                    }
2103
2104                    #[allow(unused_variables)]
2105                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2106                    where
2107                        E: serde::de::Error,
2108                    {
2109                        match value {
2110                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2111                            "graphs" => Ok(GeneratedField::Graphs),
2112                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2113                        }
2114                    }
2115                }
2116                deserializer.deserialize_identifier(GeneratedVisitor)
2117            }
2118        }
2119        struct GeneratedVisitor;
2120        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2121            type Value = streaming_control_stream_request::DatabaseInitialPartialGraph;
2122
2123            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2124                formatter.write_str("struct stream_service.StreamingControlStreamRequest.DatabaseInitialPartialGraph")
2125            }
2126
2127            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::DatabaseInitialPartialGraph, V::Error>
2128                where
2129                    V: serde::de::MapAccess<'de>,
2130            {
2131                let mut database_id__ = None;
2132                let mut graphs__ = None;
2133                while let Some(k) = map_.next_key()? {
2134                    match k {
2135                        GeneratedField::DatabaseId => {
2136                            if database_id__.is_some() {
2137                                return Err(serde::de::Error::duplicate_field("databaseId"));
2138                            }
2139                            database_id__ = 
2140                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2141                            ;
2142                        }
2143                        GeneratedField::Graphs => {
2144                            if graphs__.is_some() {
2145                                return Err(serde::de::Error::duplicate_field("graphs"));
2146                            }
2147                            graphs__ = Some(map_.next_value()?);
2148                        }
2149                    }
2150                }
2151                Ok(streaming_control_stream_request::DatabaseInitialPartialGraph {
2152                    database_id: database_id__.unwrap_or_default(),
2153                    graphs: graphs__.unwrap_or_default(),
2154                })
2155            }
2156        }
2157        deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.DatabaseInitialPartialGraph", FIELDS, GeneratedVisitor)
2158    }
2159}
2160impl serde::Serialize for streaming_control_stream_request::InitRequest {
2161    #[allow(deprecated)]
2162    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2163    where
2164        S: serde::Serializer,
2165    {
2166        use serde::ser::SerializeStruct;
2167        let mut len = 0;
2168        if !self.databases.is_empty() {
2169            len += 1;
2170        }
2171        if !self.term_id.is_empty() {
2172            len += 1;
2173        }
2174        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.InitRequest", len)?;
2175        if !self.databases.is_empty() {
2176            struct_ser.serialize_field("databases", &self.databases)?;
2177        }
2178        if !self.term_id.is_empty() {
2179            struct_ser.serialize_field("termId", &self.term_id)?;
2180        }
2181        struct_ser.end()
2182    }
2183}
2184impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::InitRequest {
2185    #[allow(deprecated)]
2186    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2187    where
2188        D: serde::Deserializer<'de>,
2189    {
2190        const FIELDS: &[&str] = &[
2191            "databases",
2192            "term_id",
2193            "termId",
2194        ];
2195
2196        #[allow(clippy::enum_variant_names)]
2197        enum GeneratedField {
2198            Databases,
2199            TermId,
2200        }
2201        impl<'de> serde::Deserialize<'de> for GeneratedField {
2202            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2203            where
2204                D: serde::Deserializer<'de>,
2205            {
2206                struct GeneratedVisitor;
2207
2208                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2209                    type Value = GeneratedField;
2210
2211                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2212                        write!(formatter, "expected one of: {:?}", &FIELDS)
2213                    }
2214
2215                    #[allow(unused_variables)]
2216                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2217                    where
2218                        E: serde::de::Error,
2219                    {
2220                        match value {
2221                            "databases" => Ok(GeneratedField::Databases),
2222                            "termId" | "term_id" => Ok(GeneratedField::TermId),
2223                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2224                        }
2225                    }
2226                }
2227                deserializer.deserialize_identifier(GeneratedVisitor)
2228            }
2229        }
2230        struct GeneratedVisitor;
2231        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2232            type Value = streaming_control_stream_request::InitRequest;
2233
2234            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2235                formatter.write_str("struct stream_service.StreamingControlStreamRequest.InitRequest")
2236            }
2237
2238            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::InitRequest, V::Error>
2239                where
2240                    V: serde::de::MapAccess<'de>,
2241            {
2242                let mut databases__ = None;
2243                let mut term_id__ = None;
2244                while let Some(k) = map_.next_key()? {
2245                    match k {
2246                        GeneratedField::Databases => {
2247                            if databases__.is_some() {
2248                                return Err(serde::de::Error::duplicate_field("databases"));
2249                            }
2250                            databases__ = Some(map_.next_value()?);
2251                        }
2252                        GeneratedField::TermId => {
2253                            if term_id__.is_some() {
2254                                return Err(serde::de::Error::duplicate_field("termId"));
2255                            }
2256                            term_id__ = Some(map_.next_value()?);
2257                        }
2258                    }
2259                }
2260                Ok(streaming_control_stream_request::InitRequest {
2261                    databases: databases__.unwrap_or_default(),
2262                    term_id: term_id__.unwrap_or_default(),
2263                })
2264            }
2265        }
2266        deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.InitRequest", FIELDS, GeneratedVisitor)
2267    }
2268}
2269impl serde::Serialize for streaming_control_stream_request::InitialPartialGraph {
2270    #[allow(deprecated)]
2271    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2272    where
2273        S: serde::Serializer,
2274    {
2275        use serde::ser::SerializeStruct;
2276        let mut len = 0;
2277        if self.partial_graph_id != 0 {
2278            len += 1;
2279        }
2280        if !self.subscriptions.is_empty() {
2281            len += 1;
2282        }
2283        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.InitialPartialGraph", len)?;
2284        if self.partial_graph_id != 0 {
2285            struct_ser.serialize_field("partialGraphId", &self.partial_graph_id)?;
2286        }
2287        if !self.subscriptions.is_empty() {
2288            struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
2289        }
2290        struct_ser.end()
2291    }
2292}
2293impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::InitialPartialGraph {
2294    #[allow(deprecated)]
2295    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2296    where
2297        D: serde::Deserializer<'de>,
2298    {
2299        const FIELDS: &[&str] = &[
2300            "partial_graph_id",
2301            "partialGraphId",
2302            "subscriptions",
2303        ];
2304
2305        #[allow(clippy::enum_variant_names)]
2306        enum GeneratedField {
2307            PartialGraphId,
2308            Subscriptions,
2309        }
2310        impl<'de> serde::Deserialize<'de> for GeneratedField {
2311            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2312            where
2313                D: serde::Deserializer<'de>,
2314            {
2315                struct GeneratedVisitor;
2316
2317                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2318                    type Value = GeneratedField;
2319
2320                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2321                        write!(formatter, "expected one of: {:?}", &FIELDS)
2322                    }
2323
2324                    #[allow(unused_variables)]
2325                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2326                    where
2327                        E: serde::de::Error,
2328                    {
2329                        match value {
2330                            "partialGraphId" | "partial_graph_id" => Ok(GeneratedField::PartialGraphId),
2331                            "subscriptions" => Ok(GeneratedField::Subscriptions),
2332                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2333                        }
2334                    }
2335                }
2336                deserializer.deserialize_identifier(GeneratedVisitor)
2337            }
2338        }
2339        struct GeneratedVisitor;
2340        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2341            type Value = streaming_control_stream_request::InitialPartialGraph;
2342
2343            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2344                formatter.write_str("struct stream_service.StreamingControlStreamRequest.InitialPartialGraph")
2345            }
2346
2347            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::InitialPartialGraph, V::Error>
2348                where
2349                    V: serde::de::MapAccess<'de>,
2350            {
2351                let mut partial_graph_id__ = None;
2352                let mut subscriptions__ = None;
2353                while let Some(k) = map_.next_key()? {
2354                    match k {
2355                        GeneratedField::PartialGraphId => {
2356                            if partial_graph_id__.is_some() {
2357                                return Err(serde::de::Error::duplicate_field("partialGraphId"));
2358                            }
2359                            partial_graph_id__ = 
2360                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2361                            ;
2362                        }
2363                        GeneratedField::Subscriptions => {
2364                            if subscriptions__.is_some() {
2365                                return Err(serde::de::Error::duplicate_field("subscriptions"));
2366                            }
2367                            subscriptions__ = Some(map_.next_value()?);
2368                        }
2369                    }
2370                }
2371                Ok(streaming_control_stream_request::InitialPartialGraph {
2372                    partial_graph_id: partial_graph_id__.unwrap_or_default(),
2373                    subscriptions: subscriptions__.unwrap_or_default(),
2374                })
2375            }
2376        }
2377        deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.InitialPartialGraph", FIELDS, GeneratedVisitor)
2378    }
2379}
2380impl serde::Serialize for streaming_control_stream_request::RemovePartialGraphRequest {
2381    #[allow(deprecated)]
2382    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2383    where
2384        S: serde::Serializer,
2385    {
2386        use serde::ser::SerializeStruct;
2387        let mut len = 0;
2388        if !self.partial_graph_ids.is_empty() {
2389            len += 1;
2390        }
2391        if self.database_id != 0 {
2392            len += 1;
2393        }
2394        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.RemovePartialGraphRequest", len)?;
2395        if !self.partial_graph_ids.is_empty() {
2396            struct_ser.serialize_field("partialGraphIds", &self.partial_graph_ids)?;
2397        }
2398        if self.database_id != 0 {
2399            struct_ser.serialize_field("databaseId", &self.database_id)?;
2400        }
2401        struct_ser.end()
2402    }
2403}
2404impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::RemovePartialGraphRequest {
2405    #[allow(deprecated)]
2406    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2407    where
2408        D: serde::Deserializer<'de>,
2409    {
2410        const FIELDS: &[&str] = &[
2411            "partial_graph_ids",
2412            "partialGraphIds",
2413            "database_id",
2414            "databaseId",
2415        ];
2416
2417        #[allow(clippy::enum_variant_names)]
2418        enum GeneratedField {
2419            PartialGraphIds,
2420            DatabaseId,
2421        }
2422        impl<'de> serde::Deserialize<'de> for GeneratedField {
2423            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2424            where
2425                D: serde::Deserializer<'de>,
2426            {
2427                struct GeneratedVisitor;
2428
2429                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2430                    type Value = GeneratedField;
2431
2432                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2433                        write!(formatter, "expected one of: {:?}", &FIELDS)
2434                    }
2435
2436                    #[allow(unused_variables)]
2437                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2438                    where
2439                        E: serde::de::Error,
2440                    {
2441                        match value {
2442                            "partialGraphIds" | "partial_graph_ids" => Ok(GeneratedField::PartialGraphIds),
2443                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2444                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2445                        }
2446                    }
2447                }
2448                deserializer.deserialize_identifier(GeneratedVisitor)
2449            }
2450        }
2451        struct GeneratedVisitor;
2452        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2453            type Value = streaming_control_stream_request::RemovePartialGraphRequest;
2454
2455            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2456                formatter.write_str("struct stream_service.StreamingControlStreamRequest.RemovePartialGraphRequest")
2457            }
2458
2459            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::RemovePartialGraphRequest, V::Error>
2460                where
2461                    V: serde::de::MapAccess<'de>,
2462            {
2463                let mut partial_graph_ids__ = None;
2464                let mut database_id__ = None;
2465                while let Some(k) = map_.next_key()? {
2466                    match k {
2467                        GeneratedField::PartialGraphIds => {
2468                            if partial_graph_ids__.is_some() {
2469                                return Err(serde::de::Error::duplicate_field("partialGraphIds"));
2470                            }
2471                            partial_graph_ids__ = 
2472                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2473                                    .into_iter().map(|x| x.0).collect())
2474                            ;
2475                        }
2476                        GeneratedField::DatabaseId => {
2477                            if database_id__.is_some() {
2478                                return Err(serde::de::Error::duplicate_field("databaseId"));
2479                            }
2480                            database_id__ = 
2481                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2482                            ;
2483                        }
2484                    }
2485                }
2486                Ok(streaming_control_stream_request::RemovePartialGraphRequest {
2487                    partial_graph_ids: partial_graph_ids__.unwrap_or_default(),
2488                    database_id: database_id__.unwrap_or_default(),
2489                })
2490            }
2491        }
2492        deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.RemovePartialGraphRequest", FIELDS, GeneratedVisitor)
2493    }
2494}
2495impl serde::Serialize for streaming_control_stream_request::ResetDatabaseRequest {
2496    #[allow(deprecated)]
2497    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2498    where
2499        S: serde::Serializer,
2500    {
2501        use serde::ser::SerializeStruct;
2502        let mut len = 0;
2503        if self.database_id != 0 {
2504            len += 1;
2505        }
2506        if self.reset_request_id != 0 {
2507            len += 1;
2508        }
2509        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamRequest.ResetDatabaseRequest", len)?;
2510        if self.database_id != 0 {
2511            struct_ser.serialize_field("databaseId", &self.database_id)?;
2512        }
2513        if self.reset_request_id != 0 {
2514            struct_ser.serialize_field("resetRequestId", &self.reset_request_id)?;
2515        }
2516        struct_ser.end()
2517    }
2518}
2519impl<'de> serde::Deserialize<'de> for streaming_control_stream_request::ResetDatabaseRequest {
2520    #[allow(deprecated)]
2521    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2522    where
2523        D: serde::Deserializer<'de>,
2524    {
2525        const FIELDS: &[&str] = &[
2526            "database_id",
2527            "databaseId",
2528            "reset_request_id",
2529            "resetRequestId",
2530        ];
2531
2532        #[allow(clippy::enum_variant_names)]
2533        enum GeneratedField {
2534            DatabaseId,
2535            ResetRequestId,
2536        }
2537        impl<'de> serde::Deserialize<'de> for GeneratedField {
2538            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2539            where
2540                D: serde::Deserializer<'de>,
2541            {
2542                struct GeneratedVisitor;
2543
2544                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2545                    type Value = GeneratedField;
2546
2547                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2548                        write!(formatter, "expected one of: {:?}", &FIELDS)
2549                    }
2550
2551                    #[allow(unused_variables)]
2552                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2553                    where
2554                        E: serde::de::Error,
2555                    {
2556                        match value {
2557                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2558                            "resetRequestId" | "reset_request_id" => Ok(GeneratedField::ResetRequestId),
2559                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2560                        }
2561                    }
2562                }
2563                deserializer.deserialize_identifier(GeneratedVisitor)
2564            }
2565        }
2566        struct GeneratedVisitor;
2567        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2568            type Value = streaming_control_stream_request::ResetDatabaseRequest;
2569
2570            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2571                formatter.write_str("struct stream_service.StreamingControlStreamRequest.ResetDatabaseRequest")
2572            }
2573
2574            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_request::ResetDatabaseRequest, V::Error>
2575                where
2576                    V: serde::de::MapAccess<'de>,
2577            {
2578                let mut database_id__ = None;
2579                let mut reset_request_id__ = None;
2580                while let Some(k) = map_.next_key()? {
2581                    match k {
2582                        GeneratedField::DatabaseId => {
2583                            if database_id__.is_some() {
2584                                return Err(serde::de::Error::duplicate_field("databaseId"));
2585                            }
2586                            database_id__ = 
2587                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2588                            ;
2589                        }
2590                        GeneratedField::ResetRequestId => {
2591                            if reset_request_id__.is_some() {
2592                                return Err(serde::de::Error::duplicate_field("resetRequestId"));
2593                            }
2594                            reset_request_id__ = 
2595                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2596                            ;
2597                        }
2598                    }
2599                }
2600                Ok(streaming_control_stream_request::ResetDatabaseRequest {
2601                    database_id: database_id__.unwrap_or_default(),
2602                    reset_request_id: reset_request_id__.unwrap_or_default(),
2603                })
2604            }
2605        }
2606        deserializer.deserialize_struct("stream_service.StreamingControlStreamRequest.ResetDatabaseRequest", FIELDS, GeneratedVisitor)
2607    }
2608}
2609impl serde::Serialize for StreamingControlStreamResponse {
2610    #[allow(deprecated)]
2611    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2612    where
2613        S: serde::Serializer,
2614    {
2615        use serde::ser::SerializeStruct;
2616        let mut len = 0;
2617        if self.response.is_some() {
2618            len += 1;
2619        }
2620        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse", len)?;
2621        if let Some(v) = self.response.as_ref() {
2622            match v {
2623                streaming_control_stream_response::Response::Init(v) => {
2624                    struct_ser.serialize_field("init", v)?;
2625                }
2626                streaming_control_stream_response::Response::CompleteBarrier(v) => {
2627                    struct_ser.serialize_field("completeBarrier", v)?;
2628                }
2629                streaming_control_stream_response::Response::Shutdown(v) => {
2630                    struct_ser.serialize_field("shutdown", v)?;
2631                }
2632                streaming_control_stream_response::Response::ReportDatabaseFailure(v) => {
2633                    struct_ser.serialize_field("reportDatabaseFailure", v)?;
2634                }
2635                streaming_control_stream_response::Response::ResetDatabase(v) => {
2636                    struct_ser.serialize_field("resetDatabase", v)?;
2637                }
2638            }
2639        }
2640        struct_ser.end()
2641    }
2642}
2643impl<'de> serde::Deserialize<'de> for StreamingControlStreamResponse {
2644    #[allow(deprecated)]
2645    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2646    where
2647        D: serde::Deserializer<'de>,
2648    {
2649        const FIELDS: &[&str] = &[
2650            "init",
2651            "complete_barrier",
2652            "completeBarrier",
2653            "shutdown",
2654            "report_database_failure",
2655            "reportDatabaseFailure",
2656            "reset_database",
2657            "resetDatabase",
2658        ];
2659
2660        #[allow(clippy::enum_variant_names)]
2661        enum GeneratedField {
2662            Init,
2663            CompleteBarrier,
2664            Shutdown,
2665            ReportDatabaseFailure,
2666            ResetDatabase,
2667        }
2668        impl<'de> serde::Deserialize<'de> for GeneratedField {
2669            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2670            where
2671                D: serde::Deserializer<'de>,
2672            {
2673                struct GeneratedVisitor;
2674
2675                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2676                    type Value = GeneratedField;
2677
2678                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2679                        write!(formatter, "expected one of: {:?}", &FIELDS)
2680                    }
2681
2682                    #[allow(unused_variables)]
2683                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2684                    where
2685                        E: serde::de::Error,
2686                    {
2687                        match value {
2688                            "init" => Ok(GeneratedField::Init),
2689                            "completeBarrier" | "complete_barrier" => Ok(GeneratedField::CompleteBarrier),
2690                            "shutdown" => Ok(GeneratedField::Shutdown),
2691                            "reportDatabaseFailure" | "report_database_failure" => Ok(GeneratedField::ReportDatabaseFailure),
2692                            "resetDatabase" | "reset_database" => Ok(GeneratedField::ResetDatabase),
2693                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2694                        }
2695                    }
2696                }
2697                deserializer.deserialize_identifier(GeneratedVisitor)
2698            }
2699        }
2700        struct GeneratedVisitor;
2701        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2702            type Value = StreamingControlStreamResponse;
2703
2704            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2705                formatter.write_str("struct stream_service.StreamingControlStreamResponse")
2706            }
2707
2708            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingControlStreamResponse, V::Error>
2709                where
2710                    V: serde::de::MapAccess<'de>,
2711            {
2712                let mut response__ = None;
2713                while let Some(k) = map_.next_key()? {
2714                    match k {
2715                        GeneratedField::Init => {
2716                            if response__.is_some() {
2717                                return Err(serde::de::Error::duplicate_field("init"));
2718                            }
2719                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::Init)
2720;
2721                        }
2722                        GeneratedField::CompleteBarrier => {
2723                            if response__.is_some() {
2724                                return Err(serde::de::Error::duplicate_field("completeBarrier"));
2725                            }
2726                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::CompleteBarrier)
2727;
2728                        }
2729                        GeneratedField::Shutdown => {
2730                            if response__.is_some() {
2731                                return Err(serde::de::Error::duplicate_field("shutdown"));
2732                            }
2733                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::Shutdown)
2734;
2735                        }
2736                        GeneratedField::ReportDatabaseFailure => {
2737                            if response__.is_some() {
2738                                return Err(serde::de::Error::duplicate_field("reportDatabaseFailure"));
2739                            }
2740                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::ReportDatabaseFailure)
2741;
2742                        }
2743                        GeneratedField::ResetDatabase => {
2744                            if response__.is_some() {
2745                                return Err(serde::de::Error::duplicate_field("resetDatabase"));
2746                            }
2747                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_control_stream_response::Response::ResetDatabase)
2748;
2749                        }
2750                    }
2751                }
2752                Ok(StreamingControlStreamResponse {
2753                    response: response__,
2754                })
2755            }
2756        }
2757        deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse", FIELDS, GeneratedVisitor)
2758    }
2759}
2760impl serde::Serialize for streaming_control_stream_response::InitResponse {
2761    #[allow(deprecated)]
2762    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2763    where
2764        S: serde::Serializer,
2765    {
2766        use serde::ser::SerializeStruct;
2767        let len = 0;
2768        let struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.InitResponse", len)?;
2769        struct_ser.end()
2770    }
2771}
2772impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::InitResponse {
2773    #[allow(deprecated)]
2774    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2775    where
2776        D: serde::Deserializer<'de>,
2777    {
2778        const FIELDS: &[&str] = &[
2779        ];
2780
2781        #[allow(clippy::enum_variant_names)]
2782        enum GeneratedField {
2783        }
2784        impl<'de> serde::Deserialize<'de> for GeneratedField {
2785            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2786            where
2787                D: serde::Deserializer<'de>,
2788            {
2789                struct GeneratedVisitor;
2790
2791                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2792                    type Value = GeneratedField;
2793
2794                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2795                        write!(formatter, "expected one of: {:?}", &FIELDS)
2796                    }
2797
2798                    #[allow(unused_variables)]
2799                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2800                    where
2801                        E: serde::de::Error,
2802                    {
2803                            Err(serde::de::Error::unknown_field(value, FIELDS))
2804                    }
2805                }
2806                deserializer.deserialize_identifier(GeneratedVisitor)
2807            }
2808        }
2809        struct GeneratedVisitor;
2810        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2811            type Value = streaming_control_stream_response::InitResponse;
2812
2813            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2814                formatter.write_str("struct stream_service.StreamingControlStreamResponse.InitResponse")
2815            }
2816
2817            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::InitResponse, V::Error>
2818                where
2819                    V: serde::de::MapAccess<'de>,
2820            {
2821                while map_.next_key::<GeneratedField>()?.is_some() {
2822                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2823                }
2824                Ok(streaming_control_stream_response::InitResponse {
2825                })
2826            }
2827        }
2828        deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.InitResponse", FIELDS, GeneratedVisitor)
2829    }
2830}
2831impl serde::Serialize for streaming_control_stream_response::ReportDatabaseFailureResponse {
2832    #[allow(deprecated)]
2833    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2834    where
2835        S: serde::Serializer,
2836    {
2837        use serde::ser::SerializeStruct;
2838        let mut len = 0;
2839        if self.database_id != 0 {
2840            len += 1;
2841        }
2842        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.ReportDatabaseFailureResponse", len)?;
2843        if self.database_id != 0 {
2844            struct_ser.serialize_field("databaseId", &self.database_id)?;
2845        }
2846        struct_ser.end()
2847    }
2848}
2849impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::ReportDatabaseFailureResponse {
2850    #[allow(deprecated)]
2851    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2852    where
2853        D: serde::Deserializer<'de>,
2854    {
2855        const FIELDS: &[&str] = &[
2856            "database_id",
2857            "databaseId",
2858        ];
2859
2860        #[allow(clippy::enum_variant_names)]
2861        enum GeneratedField {
2862            DatabaseId,
2863        }
2864        impl<'de> serde::Deserialize<'de> for GeneratedField {
2865            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2866            where
2867                D: serde::Deserializer<'de>,
2868            {
2869                struct GeneratedVisitor;
2870
2871                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2872                    type Value = GeneratedField;
2873
2874                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2875                        write!(formatter, "expected one of: {:?}", &FIELDS)
2876                    }
2877
2878                    #[allow(unused_variables)]
2879                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2880                    where
2881                        E: serde::de::Error,
2882                    {
2883                        match value {
2884                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2885                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2886                        }
2887                    }
2888                }
2889                deserializer.deserialize_identifier(GeneratedVisitor)
2890            }
2891        }
2892        struct GeneratedVisitor;
2893        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2894            type Value = streaming_control_stream_response::ReportDatabaseFailureResponse;
2895
2896            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2897                formatter.write_str("struct stream_service.StreamingControlStreamResponse.ReportDatabaseFailureResponse")
2898            }
2899
2900            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::ReportDatabaseFailureResponse, V::Error>
2901                where
2902                    V: serde::de::MapAccess<'de>,
2903            {
2904                let mut database_id__ = None;
2905                while let Some(k) = map_.next_key()? {
2906                    match k {
2907                        GeneratedField::DatabaseId => {
2908                            if database_id__.is_some() {
2909                                return Err(serde::de::Error::duplicate_field("databaseId"));
2910                            }
2911                            database_id__ = 
2912                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2913                            ;
2914                        }
2915                    }
2916                }
2917                Ok(streaming_control_stream_response::ReportDatabaseFailureResponse {
2918                    database_id: database_id__.unwrap_or_default(),
2919                })
2920            }
2921        }
2922        deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.ReportDatabaseFailureResponse", FIELDS, GeneratedVisitor)
2923    }
2924}
2925impl serde::Serialize for streaming_control_stream_response::ResetDatabaseResponse {
2926    #[allow(deprecated)]
2927    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2928    where
2929        S: serde::Serializer,
2930    {
2931        use serde::ser::SerializeStruct;
2932        let mut len = 0;
2933        if self.database_id != 0 {
2934            len += 1;
2935        }
2936        if self.root_err.is_some() {
2937            len += 1;
2938        }
2939        if self.reset_request_id != 0 {
2940            len += 1;
2941        }
2942        let mut struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.ResetDatabaseResponse", len)?;
2943        if self.database_id != 0 {
2944            struct_ser.serialize_field("databaseId", &self.database_id)?;
2945        }
2946        if let Some(v) = self.root_err.as_ref() {
2947            struct_ser.serialize_field("rootErr", v)?;
2948        }
2949        if self.reset_request_id != 0 {
2950            struct_ser.serialize_field("resetRequestId", &self.reset_request_id)?;
2951        }
2952        struct_ser.end()
2953    }
2954}
2955impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::ResetDatabaseResponse {
2956    #[allow(deprecated)]
2957    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2958    where
2959        D: serde::Deserializer<'de>,
2960    {
2961        const FIELDS: &[&str] = &[
2962            "database_id",
2963            "databaseId",
2964            "root_err",
2965            "rootErr",
2966            "reset_request_id",
2967            "resetRequestId",
2968        ];
2969
2970        #[allow(clippy::enum_variant_names)]
2971        enum GeneratedField {
2972            DatabaseId,
2973            RootErr,
2974            ResetRequestId,
2975        }
2976        impl<'de> serde::Deserialize<'de> for GeneratedField {
2977            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2978            where
2979                D: serde::Deserializer<'de>,
2980            {
2981                struct GeneratedVisitor;
2982
2983                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2984                    type Value = GeneratedField;
2985
2986                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2987                        write!(formatter, "expected one of: {:?}", &FIELDS)
2988                    }
2989
2990                    #[allow(unused_variables)]
2991                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2992                    where
2993                        E: serde::de::Error,
2994                    {
2995                        match value {
2996                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2997                            "rootErr" | "root_err" => Ok(GeneratedField::RootErr),
2998                            "resetRequestId" | "reset_request_id" => Ok(GeneratedField::ResetRequestId),
2999                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3000                        }
3001                    }
3002                }
3003                deserializer.deserialize_identifier(GeneratedVisitor)
3004            }
3005        }
3006        struct GeneratedVisitor;
3007        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3008            type Value = streaming_control_stream_response::ResetDatabaseResponse;
3009
3010            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3011                formatter.write_str("struct stream_service.StreamingControlStreamResponse.ResetDatabaseResponse")
3012            }
3013
3014            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::ResetDatabaseResponse, V::Error>
3015                where
3016                    V: serde::de::MapAccess<'de>,
3017            {
3018                let mut database_id__ = None;
3019                let mut root_err__ = None;
3020                let mut reset_request_id__ = None;
3021                while let Some(k) = map_.next_key()? {
3022                    match k {
3023                        GeneratedField::DatabaseId => {
3024                            if database_id__.is_some() {
3025                                return Err(serde::de::Error::duplicate_field("databaseId"));
3026                            }
3027                            database_id__ = 
3028                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3029                            ;
3030                        }
3031                        GeneratedField::RootErr => {
3032                            if root_err__.is_some() {
3033                                return Err(serde::de::Error::duplicate_field("rootErr"));
3034                            }
3035                            root_err__ = map_.next_value()?;
3036                        }
3037                        GeneratedField::ResetRequestId => {
3038                            if reset_request_id__.is_some() {
3039                                return Err(serde::de::Error::duplicate_field("resetRequestId"));
3040                            }
3041                            reset_request_id__ = 
3042                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3043                            ;
3044                        }
3045                    }
3046                }
3047                Ok(streaming_control_stream_response::ResetDatabaseResponse {
3048                    database_id: database_id__.unwrap_or_default(),
3049                    root_err: root_err__,
3050                    reset_request_id: reset_request_id__.unwrap_or_default(),
3051                })
3052            }
3053        }
3054        deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.ResetDatabaseResponse", FIELDS, GeneratedVisitor)
3055    }
3056}
3057impl serde::Serialize for streaming_control_stream_response::ShutdownResponse {
3058    #[allow(deprecated)]
3059    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3060    where
3061        S: serde::Serializer,
3062    {
3063        use serde::ser::SerializeStruct;
3064        let len = 0;
3065        let struct_ser = serializer.serialize_struct("stream_service.StreamingControlStreamResponse.ShutdownResponse", len)?;
3066        struct_ser.end()
3067    }
3068}
3069impl<'de> serde::Deserialize<'de> for streaming_control_stream_response::ShutdownResponse {
3070    #[allow(deprecated)]
3071    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3072    where
3073        D: serde::Deserializer<'de>,
3074    {
3075        const FIELDS: &[&str] = &[
3076        ];
3077
3078        #[allow(clippy::enum_variant_names)]
3079        enum GeneratedField {
3080        }
3081        impl<'de> serde::Deserialize<'de> for GeneratedField {
3082            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3083            where
3084                D: serde::Deserializer<'de>,
3085            {
3086                struct GeneratedVisitor;
3087
3088                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3089                    type Value = GeneratedField;
3090
3091                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3092                        write!(formatter, "expected one of: {:?}", &FIELDS)
3093                    }
3094
3095                    #[allow(unused_variables)]
3096                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3097                    where
3098                        E: serde::de::Error,
3099                    {
3100                            Err(serde::de::Error::unknown_field(value, FIELDS))
3101                    }
3102                }
3103                deserializer.deserialize_identifier(GeneratedVisitor)
3104            }
3105        }
3106        struct GeneratedVisitor;
3107        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3108            type Value = streaming_control_stream_response::ShutdownResponse;
3109
3110            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3111                formatter.write_str("struct stream_service.StreamingControlStreamResponse.ShutdownResponse")
3112            }
3113
3114            fn visit_map<V>(self, mut map_: V) -> std::result::Result<streaming_control_stream_response::ShutdownResponse, V::Error>
3115                where
3116                    V: serde::de::MapAccess<'de>,
3117            {
3118                while map_.next_key::<GeneratedField>()?.is_some() {
3119                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3120                }
3121                Ok(streaming_control_stream_response::ShutdownResponse {
3122                })
3123            }
3124        }
3125        deserializer.deserialize_struct("stream_service.StreamingControlStreamResponse.ShutdownResponse", FIELDS, GeneratedVisitor)
3126    }
3127}