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