risingwave_pb/
ddl_service.serde.rs

1use crate::ddl_service::*;
2impl serde::Serialize for AlterCdcTableBackfillParallelismRequest {
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.table_id != 0 {
11            len += 1;
12        }
13        if self.parallelism.is_some() {
14            len += 1;
15        }
16        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", len)?;
17        if self.table_id != 0 {
18            struct_ser.serialize_field("tableId", &self.table_id)?;
19        }
20        if let Some(v) = self.parallelism.as_ref() {
21            struct_ser.serialize_field("parallelism", v)?;
22        }
23        struct_ser.end()
24    }
25}
26impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismRequest {
27    #[allow(deprecated)]
28    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29    where
30        D: serde::Deserializer<'de>,
31    {
32        const FIELDS: &[&str] = &[
33            "table_id",
34            "tableId",
35            "parallelism",
36        ];
37
38        #[allow(clippy::enum_variant_names)]
39        enum GeneratedField {
40            TableId,
41            Parallelism,
42        }
43        impl<'de> serde::Deserialize<'de> for GeneratedField {
44            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45            where
46                D: serde::Deserializer<'de>,
47            {
48                struct GeneratedVisitor;
49
50                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51                    type Value = GeneratedField;
52
53                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54                        write!(formatter, "expected one of: {:?}", &FIELDS)
55                    }
56
57                    #[allow(unused_variables)]
58                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59                    where
60                        E: serde::de::Error,
61                    {
62                        match value {
63                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
64                            "parallelism" => Ok(GeneratedField::Parallelism),
65                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66                        }
67                    }
68                }
69                deserializer.deserialize_identifier(GeneratedVisitor)
70            }
71        }
72        struct GeneratedVisitor;
73        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74            type Value = AlterCdcTableBackfillParallelismRequest;
75
76            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77                formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismRequest")
78            }
79
80            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismRequest, V::Error>
81                where
82                    V: serde::de::MapAccess<'de>,
83            {
84                let mut table_id__ = None;
85                let mut parallelism__ = None;
86                while let Some(k) = map_.next_key()? {
87                    match k {
88                        GeneratedField::TableId => {
89                            if table_id__.is_some() {
90                                return Err(serde::de::Error::duplicate_field("tableId"));
91                            }
92                            table_id__ = 
93                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
94                            ;
95                        }
96                        GeneratedField::Parallelism => {
97                            if parallelism__.is_some() {
98                                return Err(serde::de::Error::duplicate_field("parallelism"));
99                            }
100                            parallelism__ = map_.next_value()?;
101                        }
102                    }
103                }
104                Ok(AlterCdcTableBackfillParallelismRequest {
105                    table_id: table_id__.unwrap_or_default(),
106                    parallelism: parallelism__,
107                })
108            }
109        }
110        deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", FIELDS, GeneratedVisitor)
111    }
112}
113impl serde::Serialize for AlterCdcTableBackfillParallelismResponse {
114    #[allow(deprecated)]
115    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
116    where
117        S: serde::Serializer,
118    {
119        use serde::ser::SerializeStruct;
120        let len = 0;
121        let struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", len)?;
122        struct_ser.end()
123    }
124}
125impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismResponse {
126    #[allow(deprecated)]
127    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
128    where
129        D: serde::Deserializer<'de>,
130    {
131        const FIELDS: &[&str] = &[
132        ];
133
134        #[allow(clippy::enum_variant_names)]
135        enum GeneratedField {
136        }
137        impl<'de> serde::Deserialize<'de> for GeneratedField {
138            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
139            where
140                D: serde::Deserializer<'de>,
141            {
142                struct GeneratedVisitor;
143
144                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
145                    type Value = GeneratedField;
146
147                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
148                        write!(formatter, "expected one of: {:?}", &FIELDS)
149                    }
150
151                    #[allow(unused_variables)]
152                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
153                    where
154                        E: serde::de::Error,
155                    {
156                            Err(serde::de::Error::unknown_field(value, FIELDS))
157                    }
158                }
159                deserializer.deserialize_identifier(GeneratedVisitor)
160            }
161        }
162        struct GeneratedVisitor;
163        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
164            type Value = AlterCdcTableBackfillParallelismResponse;
165
166            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
167                formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismResponse")
168            }
169
170            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismResponse, V::Error>
171                where
172                    V: serde::de::MapAccess<'de>,
173            {
174                while map_.next_key::<GeneratedField>()?.is_some() {
175                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
176                }
177                Ok(AlterCdcTableBackfillParallelismResponse {
178                })
179            }
180        }
181        deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", FIELDS, GeneratedVisitor)
182    }
183}
184impl serde::Serialize for AlterDatabaseParamRequest {
185    #[allow(deprecated)]
186    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
187    where
188        S: serde::Serializer,
189    {
190        use serde::ser::SerializeStruct;
191        let mut len = 0;
192        if self.database_id != 0 {
193            len += 1;
194        }
195        if self.param.is_some() {
196            len += 1;
197        }
198        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamRequest", len)?;
199        if self.database_id != 0 {
200            struct_ser.serialize_field("databaseId", &self.database_id)?;
201        }
202        if let Some(v) = self.param.as_ref() {
203            match v {
204                alter_database_param_request::Param::BarrierIntervalMs(v) => {
205                    struct_ser.serialize_field("barrierIntervalMs", v)?;
206                }
207                alter_database_param_request::Param::CheckpointFrequency(v) => {
208                    struct_ser.serialize_field("checkpointFrequency", v)?;
209                }
210            }
211        }
212        struct_ser.end()
213    }
214}
215impl<'de> serde::Deserialize<'de> for AlterDatabaseParamRequest {
216    #[allow(deprecated)]
217    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
218    where
219        D: serde::Deserializer<'de>,
220    {
221        const FIELDS: &[&str] = &[
222            "database_id",
223            "databaseId",
224            "barrier_interval_ms",
225            "barrierIntervalMs",
226            "checkpoint_frequency",
227            "checkpointFrequency",
228        ];
229
230        #[allow(clippy::enum_variant_names)]
231        enum GeneratedField {
232            DatabaseId,
233            BarrierIntervalMs,
234            CheckpointFrequency,
235        }
236        impl<'de> serde::Deserialize<'de> for GeneratedField {
237            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
238            where
239                D: serde::Deserializer<'de>,
240            {
241                struct GeneratedVisitor;
242
243                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
244                    type Value = GeneratedField;
245
246                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
247                        write!(formatter, "expected one of: {:?}", &FIELDS)
248                    }
249
250                    #[allow(unused_variables)]
251                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
252                    where
253                        E: serde::de::Error,
254                    {
255                        match value {
256                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
257                            "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
258                            "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
259                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
260                        }
261                    }
262                }
263                deserializer.deserialize_identifier(GeneratedVisitor)
264            }
265        }
266        struct GeneratedVisitor;
267        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
268            type Value = AlterDatabaseParamRequest;
269
270            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
271                formatter.write_str("struct ddl_service.AlterDatabaseParamRequest")
272            }
273
274            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamRequest, V::Error>
275                where
276                    V: serde::de::MapAccess<'de>,
277            {
278                let mut database_id__ = None;
279                let mut param__ = None;
280                while let Some(k) = map_.next_key()? {
281                    match k {
282                        GeneratedField::DatabaseId => {
283                            if database_id__.is_some() {
284                                return Err(serde::de::Error::duplicate_field("databaseId"));
285                            }
286                            database_id__ = 
287                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
288                            ;
289                        }
290                        GeneratedField::BarrierIntervalMs => {
291                            if param__.is_some() {
292                                return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
293                            }
294                            param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::BarrierIntervalMs)
295;
296                        }
297                        GeneratedField::CheckpointFrequency => {
298                            if param__.is_some() {
299                                return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
300                            }
301                            param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::CheckpointFrequency)
302;
303                        }
304                    }
305                }
306                Ok(AlterDatabaseParamRequest {
307                    database_id: database_id__.unwrap_or_default(),
308                    param: param__,
309                })
310            }
311        }
312        deserializer.deserialize_struct("ddl_service.AlterDatabaseParamRequest", FIELDS, GeneratedVisitor)
313    }
314}
315impl serde::Serialize for AlterDatabaseParamResponse {
316    #[allow(deprecated)]
317    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
318    where
319        S: serde::Serializer,
320    {
321        use serde::ser::SerializeStruct;
322        let mut len = 0;
323        if self.status.is_some() {
324            len += 1;
325        }
326        if self.version.is_some() {
327            len += 1;
328        }
329        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamResponse", len)?;
330        if let Some(v) = self.status.as_ref() {
331            struct_ser.serialize_field("status", v)?;
332        }
333        if let Some(v) = self.version.as_ref() {
334            struct_ser.serialize_field("version", v)?;
335        }
336        struct_ser.end()
337    }
338}
339impl<'de> serde::Deserialize<'de> for AlterDatabaseParamResponse {
340    #[allow(deprecated)]
341    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
342    where
343        D: serde::Deserializer<'de>,
344    {
345        const FIELDS: &[&str] = &[
346            "status",
347            "version",
348        ];
349
350        #[allow(clippy::enum_variant_names)]
351        enum GeneratedField {
352            Status,
353            Version,
354        }
355        impl<'de> serde::Deserialize<'de> for GeneratedField {
356            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
357            where
358                D: serde::Deserializer<'de>,
359            {
360                struct GeneratedVisitor;
361
362                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
363                    type Value = GeneratedField;
364
365                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
366                        write!(formatter, "expected one of: {:?}", &FIELDS)
367                    }
368
369                    #[allow(unused_variables)]
370                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
371                    where
372                        E: serde::de::Error,
373                    {
374                        match value {
375                            "status" => Ok(GeneratedField::Status),
376                            "version" => Ok(GeneratedField::Version),
377                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
378                        }
379                    }
380                }
381                deserializer.deserialize_identifier(GeneratedVisitor)
382            }
383        }
384        struct GeneratedVisitor;
385        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
386            type Value = AlterDatabaseParamResponse;
387
388            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
389                formatter.write_str("struct ddl_service.AlterDatabaseParamResponse")
390            }
391
392            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamResponse, V::Error>
393                where
394                    V: serde::de::MapAccess<'de>,
395            {
396                let mut status__ = None;
397                let mut version__ = None;
398                while let Some(k) = map_.next_key()? {
399                    match k {
400                        GeneratedField::Status => {
401                            if status__.is_some() {
402                                return Err(serde::de::Error::duplicate_field("status"));
403                            }
404                            status__ = map_.next_value()?;
405                        }
406                        GeneratedField::Version => {
407                            if version__.is_some() {
408                                return Err(serde::de::Error::duplicate_field("version"));
409                            }
410                            version__ = map_.next_value()?;
411                        }
412                    }
413                }
414                Ok(AlterDatabaseParamResponse {
415                    status: status__,
416                    version: version__,
417                })
418            }
419        }
420        deserializer.deserialize_struct("ddl_service.AlterDatabaseParamResponse", FIELDS, GeneratedVisitor)
421    }
422}
423impl serde::Serialize for AlterNameRequest {
424    #[allow(deprecated)]
425    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
426    where
427        S: serde::Serializer,
428    {
429        use serde::ser::SerializeStruct;
430        let mut len = 0;
431        if !self.new_name.is_empty() {
432            len += 1;
433        }
434        if self.object.is_some() {
435            len += 1;
436        }
437        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameRequest", len)?;
438        if !self.new_name.is_empty() {
439            struct_ser.serialize_field("newName", &self.new_name)?;
440        }
441        if let Some(v) = self.object.as_ref() {
442            match v {
443                alter_name_request::Object::TableId(v) => {
444                    struct_ser.serialize_field("tableId", v)?;
445                }
446                alter_name_request::Object::ViewId(v) => {
447                    struct_ser.serialize_field("viewId", v)?;
448                }
449                alter_name_request::Object::IndexId(v) => {
450                    struct_ser.serialize_field("indexId", v)?;
451                }
452                alter_name_request::Object::SinkId(v) => {
453                    struct_ser.serialize_field("sinkId", v)?;
454                }
455                alter_name_request::Object::SourceId(v) => {
456                    struct_ser.serialize_field("sourceId", v)?;
457                }
458                alter_name_request::Object::SchemaId(v) => {
459                    struct_ser.serialize_field("schemaId", v)?;
460                }
461                alter_name_request::Object::DatabaseId(v) => {
462                    struct_ser.serialize_field("databaseId", v)?;
463                }
464                alter_name_request::Object::SubscriptionId(v) => {
465                    struct_ser.serialize_field("subscriptionId", v)?;
466                }
467            }
468        }
469        struct_ser.end()
470    }
471}
472impl<'de> serde::Deserialize<'de> for AlterNameRequest {
473    #[allow(deprecated)]
474    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
475    where
476        D: serde::Deserializer<'de>,
477    {
478        const FIELDS: &[&str] = &[
479            "new_name",
480            "newName",
481            "table_id",
482            "tableId",
483            "view_id",
484            "viewId",
485            "index_id",
486            "indexId",
487            "sink_id",
488            "sinkId",
489            "source_id",
490            "sourceId",
491            "schema_id",
492            "schemaId",
493            "database_id",
494            "databaseId",
495            "subscription_id",
496            "subscriptionId",
497        ];
498
499        #[allow(clippy::enum_variant_names)]
500        enum GeneratedField {
501            NewName,
502            TableId,
503            ViewId,
504            IndexId,
505            SinkId,
506            SourceId,
507            SchemaId,
508            DatabaseId,
509            SubscriptionId,
510        }
511        impl<'de> serde::Deserialize<'de> for GeneratedField {
512            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
513            where
514                D: serde::Deserializer<'de>,
515            {
516                struct GeneratedVisitor;
517
518                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
519                    type Value = GeneratedField;
520
521                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
522                        write!(formatter, "expected one of: {:?}", &FIELDS)
523                    }
524
525                    #[allow(unused_variables)]
526                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
527                    where
528                        E: serde::de::Error,
529                    {
530                        match value {
531                            "newName" | "new_name" => Ok(GeneratedField::NewName),
532                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
533                            "viewId" | "view_id" => Ok(GeneratedField::ViewId),
534                            "indexId" | "index_id" => Ok(GeneratedField::IndexId),
535                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
536                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
537                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
538                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
539                            "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
540                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
541                        }
542                    }
543                }
544                deserializer.deserialize_identifier(GeneratedVisitor)
545            }
546        }
547        struct GeneratedVisitor;
548        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
549            type Value = AlterNameRequest;
550
551            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
552                formatter.write_str("struct ddl_service.AlterNameRequest")
553            }
554
555            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameRequest, V::Error>
556                where
557                    V: serde::de::MapAccess<'de>,
558            {
559                let mut new_name__ = None;
560                let mut object__ = None;
561                while let Some(k) = map_.next_key()? {
562                    match k {
563                        GeneratedField::NewName => {
564                            if new_name__.is_some() {
565                                return Err(serde::de::Error::duplicate_field("newName"));
566                            }
567                            new_name__ = Some(map_.next_value()?);
568                        }
569                        GeneratedField::TableId => {
570                            if object__.is_some() {
571                                return Err(serde::de::Error::duplicate_field("tableId"));
572                            }
573                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::TableId(x.0));
574                        }
575                        GeneratedField::ViewId => {
576                            if object__.is_some() {
577                                return Err(serde::de::Error::duplicate_field("viewId"));
578                            }
579                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::ViewId(x.0));
580                        }
581                        GeneratedField::IndexId => {
582                            if object__.is_some() {
583                                return Err(serde::de::Error::duplicate_field("indexId"));
584                            }
585                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::IndexId(x.0));
586                        }
587                        GeneratedField::SinkId => {
588                            if object__.is_some() {
589                                return Err(serde::de::Error::duplicate_field("sinkId"));
590                            }
591                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SinkId(x.0));
592                        }
593                        GeneratedField::SourceId => {
594                            if object__.is_some() {
595                                return Err(serde::de::Error::duplicate_field("sourceId"));
596                            }
597                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SourceId(x.0));
598                        }
599                        GeneratedField::SchemaId => {
600                            if object__.is_some() {
601                                return Err(serde::de::Error::duplicate_field("schemaId"));
602                            }
603                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SchemaId(x.0));
604                        }
605                        GeneratedField::DatabaseId => {
606                            if object__.is_some() {
607                                return Err(serde::de::Error::duplicate_field("databaseId"));
608                            }
609                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::DatabaseId(x.0));
610                        }
611                        GeneratedField::SubscriptionId => {
612                            if object__.is_some() {
613                                return Err(serde::de::Error::duplicate_field("subscriptionId"));
614                            }
615                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SubscriptionId(x.0));
616                        }
617                    }
618                }
619                Ok(AlterNameRequest {
620                    new_name: new_name__.unwrap_or_default(),
621                    object: object__,
622                })
623            }
624        }
625        deserializer.deserialize_struct("ddl_service.AlterNameRequest", FIELDS, GeneratedVisitor)
626    }
627}
628impl serde::Serialize for AlterNameResponse {
629    #[allow(deprecated)]
630    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
631    where
632        S: serde::Serializer,
633    {
634        use serde::ser::SerializeStruct;
635        let mut len = 0;
636        if self.status.is_some() {
637            len += 1;
638        }
639        if self.version.is_some() {
640            len += 1;
641        }
642        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameResponse", len)?;
643        if let Some(v) = self.status.as_ref() {
644            struct_ser.serialize_field("status", v)?;
645        }
646        if let Some(v) = self.version.as_ref() {
647            struct_ser.serialize_field("version", v)?;
648        }
649        struct_ser.end()
650    }
651}
652impl<'de> serde::Deserialize<'de> for AlterNameResponse {
653    #[allow(deprecated)]
654    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
655    where
656        D: serde::Deserializer<'de>,
657    {
658        const FIELDS: &[&str] = &[
659            "status",
660            "version",
661        ];
662
663        #[allow(clippy::enum_variant_names)]
664        enum GeneratedField {
665            Status,
666            Version,
667        }
668        impl<'de> serde::Deserialize<'de> for GeneratedField {
669            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
670            where
671                D: serde::Deserializer<'de>,
672            {
673                struct GeneratedVisitor;
674
675                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
676                    type Value = GeneratedField;
677
678                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
679                        write!(formatter, "expected one of: {:?}", &FIELDS)
680                    }
681
682                    #[allow(unused_variables)]
683                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
684                    where
685                        E: serde::de::Error,
686                    {
687                        match value {
688                            "status" => Ok(GeneratedField::Status),
689                            "version" => Ok(GeneratedField::Version),
690                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
691                        }
692                    }
693                }
694                deserializer.deserialize_identifier(GeneratedVisitor)
695            }
696        }
697        struct GeneratedVisitor;
698        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
699            type Value = AlterNameResponse;
700
701            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
702                formatter.write_str("struct ddl_service.AlterNameResponse")
703            }
704
705            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameResponse, V::Error>
706                where
707                    V: serde::de::MapAccess<'de>,
708            {
709                let mut status__ = None;
710                let mut version__ = None;
711                while let Some(k) = map_.next_key()? {
712                    match k {
713                        GeneratedField::Status => {
714                            if status__.is_some() {
715                                return Err(serde::de::Error::duplicate_field("status"));
716                            }
717                            status__ = map_.next_value()?;
718                        }
719                        GeneratedField::Version => {
720                            if version__.is_some() {
721                                return Err(serde::de::Error::duplicate_field("version"));
722                            }
723                            version__ = map_.next_value()?;
724                        }
725                    }
726                }
727                Ok(AlterNameResponse {
728                    status: status__,
729                    version: version__,
730                })
731            }
732        }
733        deserializer.deserialize_struct("ddl_service.AlterNameResponse", FIELDS, GeneratedVisitor)
734    }
735}
736impl serde::Serialize for AlterOwnerRequest {
737    #[allow(deprecated)]
738    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
739    where
740        S: serde::Serializer,
741    {
742        use serde::ser::SerializeStruct;
743        let mut len = 0;
744        if self.owner_id != 0 {
745            len += 1;
746        }
747        if self.object.is_some() {
748            len += 1;
749        }
750        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerRequest", len)?;
751        if self.owner_id != 0 {
752            struct_ser.serialize_field("ownerId", &self.owner_id)?;
753        }
754        if let Some(v) = self.object.as_ref() {
755            match v {
756                alter_owner_request::Object::TableId(v) => {
757                    struct_ser.serialize_field("tableId", v)?;
758                }
759                alter_owner_request::Object::ViewId(v) => {
760                    struct_ser.serialize_field("viewId", v)?;
761                }
762                alter_owner_request::Object::SourceId(v) => {
763                    struct_ser.serialize_field("sourceId", v)?;
764                }
765                alter_owner_request::Object::SinkId(v) => {
766                    struct_ser.serialize_field("sinkId", v)?;
767                }
768                alter_owner_request::Object::SchemaId(v) => {
769                    struct_ser.serialize_field("schemaId", v)?;
770                }
771                alter_owner_request::Object::DatabaseId(v) => {
772                    struct_ser.serialize_field("databaseId", v)?;
773                }
774                alter_owner_request::Object::SubscriptionId(v) => {
775                    struct_ser.serialize_field("subscriptionId", v)?;
776                }
777                alter_owner_request::Object::ConnectionId(v) => {
778                    struct_ser.serialize_field("connectionId", v)?;
779                }
780            }
781        }
782        struct_ser.end()
783    }
784}
785impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
786    #[allow(deprecated)]
787    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
788    where
789        D: serde::Deserializer<'de>,
790    {
791        const FIELDS: &[&str] = &[
792            "owner_id",
793            "ownerId",
794            "table_id",
795            "tableId",
796            "view_id",
797            "viewId",
798            "source_id",
799            "sourceId",
800            "sink_id",
801            "sinkId",
802            "schema_id",
803            "schemaId",
804            "database_id",
805            "databaseId",
806            "subscription_id",
807            "subscriptionId",
808            "connection_id",
809            "connectionId",
810        ];
811
812        #[allow(clippy::enum_variant_names)]
813        enum GeneratedField {
814            OwnerId,
815            TableId,
816            ViewId,
817            SourceId,
818            SinkId,
819            SchemaId,
820            DatabaseId,
821            SubscriptionId,
822            ConnectionId,
823        }
824        impl<'de> serde::Deserialize<'de> for GeneratedField {
825            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
826            where
827                D: serde::Deserializer<'de>,
828            {
829                struct GeneratedVisitor;
830
831                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
832                    type Value = GeneratedField;
833
834                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
835                        write!(formatter, "expected one of: {:?}", &FIELDS)
836                    }
837
838                    #[allow(unused_variables)]
839                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
840                    where
841                        E: serde::de::Error,
842                    {
843                        match value {
844                            "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
845                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
846                            "viewId" | "view_id" => Ok(GeneratedField::ViewId),
847                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
848                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
849                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
850                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
851                            "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
852                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
853                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
854                        }
855                    }
856                }
857                deserializer.deserialize_identifier(GeneratedVisitor)
858            }
859        }
860        struct GeneratedVisitor;
861        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
862            type Value = AlterOwnerRequest;
863
864            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
865                formatter.write_str("struct ddl_service.AlterOwnerRequest")
866            }
867
868            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
869                where
870                    V: serde::de::MapAccess<'de>,
871            {
872                let mut owner_id__ = None;
873                let mut object__ = None;
874                while let Some(k) = map_.next_key()? {
875                    match k {
876                        GeneratedField::OwnerId => {
877                            if owner_id__.is_some() {
878                                return Err(serde::de::Error::duplicate_field("ownerId"));
879                            }
880                            owner_id__ = 
881                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
882                            ;
883                        }
884                        GeneratedField::TableId => {
885                            if object__.is_some() {
886                                return Err(serde::de::Error::duplicate_field("tableId"));
887                            }
888                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
889                        }
890                        GeneratedField::ViewId => {
891                            if object__.is_some() {
892                                return Err(serde::de::Error::duplicate_field("viewId"));
893                            }
894                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
895                        }
896                        GeneratedField::SourceId => {
897                            if object__.is_some() {
898                                return Err(serde::de::Error::duplicate_field("sourceId"));
899                            }
900                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
901                        }
902                        GeneratedField::SinkId => {
903                            if object__.is_some() {
904                                return Err(serde::de::Error::duplicate_field("sinkId"));
905                            }
906                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
907                        }
908                        GeneratedField::SchemaId => {
909                            if object__.is_some() {
910                                return Err(serde::de::Error::duplicate_field("schemaId"));
911                            }
912                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
913                        }
914                        GeneratedField::DatabaseId => {
915                            if object__.is_some() {
916                                return Err(serde::de::Error::duplicate_field("databaseId"));
917                            }
918                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
919                        }
920                        GeneratedField::SubscriptionId => {
921                            if object__.is_some() {
922                                return Err(serde::de::Error::duplicate_field("subscriptionId"));
923                            }
924                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
925                        }
926                        GeneratedField::ConnectionId => {
927                            if object__.is_some() {
928                                return Err(serde::de::Error::duplicate_field("connectionId"));
929                            }
930                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
931                        }
932                    }
933                }
934                Ok(AlterOwnerRequest {
935                    owner_id: owner_id__.unwrap_or_default(),
936                    object: object__,
937                })
938            }
939        }
940        deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
941    }
942}
943impl serde::Serialize for AlterOwnerResponse {
944    #[allow(deprecated)]
945    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
946    where
947        S: serde::Serializer,
948    {
949        use serde::ser::SerializeStruct;
950        let mut len = 0;
951        if self.status.is_some() {
952            len += 1;
953        }
954        if self.version.is_some() {
955            len += 1;
956        }
957        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
958        if let Some(v) = self.status.as_ref() {
959            struct_ser.serialize_field("status", v)?;
960        }
961        if let Some(v) = self.version.as_ref() {
962            struct_ser.serialize_field("version", v)?;
963        }
964        struct_ser.end()
965    }
966}
967impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
968    #[allow(deprecated)]
969    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
970    where
971        D: serde::Deserializer<'de>,
972    {
973        const FIELDS: &[&str] = &[
974            "status",
975            "version",
976        ];
977
978        #[allow(clippy::enum_variant_names)]
979        enum GeneratedField {
980            Status,
981            Version,
982        }
983        impl<'de> serde::Deserialize<'de> for GeneratedField {
984            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
985            where
986                D: serde::Deserializer<'de>,
987            {
988                struct GeneratedVisitor;
989
990                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
991                    type Value = GeneratedField;
992
993                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
994                        write!(formatter, "expected one of: {:?}", &FIELDS)
995                    }
996
997                    #[allow(unused_variables)]
998                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
999                    where
1000                        E: serde::de::Error,
1001                    {
1002                        match value {
1003                            "status" => Ok(GeneratedField::Status),
1004                            "version" => Ok(GeneratedField::Version),
1005                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1006                        }
1007                    }
1008                }
1009                deserializer.deserialize_identifier(GeneratedVisitor)
1010            }
1011        }
1012        struct GeneratedVisitor;
1013        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1014            type Value = AlterOwnerResponse;
1015
1016            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1017                formatter.write_str("struct ddl_service.AlterOwnerResponse")
1018            }
1019
1020            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1021                where
1022                    V: serde::de::MapAccess<'de>,
1023            {
1024                let mut status__ = None;
1025                let mut version__ = None;
1026                while let Some(k) = map_.next_key()? {
1027                    match k {
1028                        GeneratedField::Status => {
1029                            if status__.is_some() {
1030                                return Err(serde::de::Error::duplicate_field("status"));
1031                            }
1032                            status__ = map_.next_value()?;
1033                        }
1034                        GeneratedField::Version => {
1035                            if version__.is_some() {
1036                                return Err(serde::de::Error::duplicate_field("version"));
1037                            }
1038                            version__ = map_.next_value()?;
1039                        }
1040                    }
1041                }
1042                Ok(AlterOwnerResponse {
1043                    status: status__,
1044                    version: version__,
1045                })
1046            }
1047        }
1048        deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1049    }
1050}
1051impl serde::Serialize for AlterParallelismRequest {
1052    #[allow(deprecated)]
1053    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1054    where
1055        S: serde::Serializer,
1056    {
1057        use serde::ser::SerializeStruct;
1058        let mut len = 0;
1059        if self.table_id != 0 {
1060            len += 1;
1061        }
1062        if self.parallelism.is_some() {
1063            len += 1;
1064        }
1065        if self.deferred {
1066            len += 1;
1067        }
1068        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1069        if self.table_id != 0 {
1070            struct_ser.serialize_field("tableId", &self.table_id)?;
1071        }
1072        if let Some(v) = self.parallelism.as_ref() {
1073            struct_ser.serialize_field("parallelism", v)?;
1074        }
1075        if self.deferred {
1076            struct_ser.serialize_field("deferred", &self.deferred)?;
1077        }
1078        struct_ser.end()
1079    }
1080}
1081impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
1082    #[allow(deprecated)]
1083    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1084    where
1085        D: serde::Deserializer<'de>,
1086    {
1087        const FIELDS: &[&str] = &[
1088            "table_id",
1089            "tableId",
1090            "parallelism",
1091            "deferred",
1092        ];
1093
1094        #[allow(clippy::enum_variant_names)]
1095        enum GeneratedField {
1096            TableId,
1097            Parallelism,
1098            Deferred,
1099        }
1100        impl<'de> serde::Deserialize<'de> for GeneratedField {
1101            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1102            where
1103                D: serde::Deserializer<'de>,
1104            {
1105                struct GeneratedVisitor;
1106
1107                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1108                    type Value = GeneratedField;
1109
1110                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1111                        write!(formatter, "expected one of: {:?}", &FIELDS)
1112                    }
1113
1114                    #[allow(unused_variables)]
1115                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1116                    where
1117                        E: serde::de::Error,
1118                    {
1119                        match value {
1120                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
1121                            "parallelism" => Ok(GeneratedField::Parallelism),
1122                            "deferred" => Ok(GeneratedField::Deferred),
1123                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1124                        }
1125                    }
1126                }
1127                deserializer.deserialize_identifier(GeneratedVisitor)
1128            }
1129        }
1130        struct GeneratedVisitor;
1131        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1132            type Value = AlterParallelismRequest;
1133
1134            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1135                formatter.write_str("struct ddl_service.AlterParallelismRequest")
1136            }
1137
1138            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1139                where
1140                    V: serde::de::MapAccess<'de>,
1141            {
1142                let mut table_id__ = None;
1143                let mut parallelism__ = None;
1144                let mut deferred__ = None;
1145                while let Some(k) = map_.next_key()? {
1146                    match k {
1147                        GeneratedField::TableId => {
1148                            if table_id__.is_some() {
1149                                return Err(serde::de::Error::duplicate_field("tableId"));
1150                            }
1151                            table_id__ = 
1152                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1153                            ;
1154                        }
1155                        GeneratedField::Parallelism => {
1156                            if parallelism__.is_some() {
1157                                return Err(serde::de::Error::duplicate_field("parallelism"));
1158                            }
1159                            parallelism__ = map_.next_value()?;
1160                        }
1161                        GeneratedField::Deferred => {
1162                            if deferred__.is_some() {
1163                                return Err(serde::de::Error::duplicate_field("deferred"));
1164                            }
1165                            deferred__ = Some(map_.next_value()?);
1166                        }
1167                    }
1168                }
1169                Ok(AlterParallelismRequest {
1170                    table_id: table_id__.unwrap_or_default(),
1171                    parallelism: parallelism__,
1172                    deferred: deferred__.unwrap_or_default(),
1173                })
1174            }
1175        }
1176        deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1177    }
1178}
1179impl serde::Serialize for AlterParallelismResponse {
1180    #[allow(deprecated)]
1181    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1182    where
1183        S: serde::Serializer,
1184    {
1185        use serde::ser::SerializeStruct;
1186        let len = 0;
1187        let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1188        struct_ser.end()
1189    }
1190}
1191impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1192    #[allow(deprecated)]
1193    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1194    where
1195        D: serde::Deserializer<'de>,
1196    {
1197        const FIELDS: &[&str] = &[
1198        ];
1199
1200        #[allow(clippy::enum_variant_names)]
1201        enum GeneratedField {
1202        }
1203        impl<'de> serde::Deserialize<'de> for GeneratedField {
1204            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1205            where
1206                D: serde::Deserializer<'de>,
1207            {
1208                struct GeneratedVisitor;
1209
1210                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1211                    type Value = GeneratedField;
1212
1213                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1214                        write!(formatter, "expected one of: {:?}", &FIELDS)
1215                    }
1216
1217                    #[allow(unused_variables)]
1218                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1219                    where
1220                        E: serde::de::Error,
1221                    {
1222                            Err(serde::de::Error::unknown_field(value, FIELDS))
1223                    }
1224                }
1225                deserializer.deserialize_identifier(GeneratedVisitor)
1226            }
1227        }
1228        struct GeneratedVisitor;
1229        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1230            type Value = AlterParallelismResponse;
1231
1232            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1233                formatter.write_str("struct ddl_service.AlterParallelismResponse")
1234            }
1235
1236            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1237                where
1238                    V: serde::de::MapAccess<'de>,
1239            {
1240                while map_.next_key::<GeneratedField>()?.is_some() {
1241                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1242                }
1243                Ok(AlterParallelismResponse {
1244                })
1245            }
1246        }
1247        deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1248    }
1249}
1250impl serde::Serialize for AlterResourceGroupRequest {
1251    #[allow(deprecated)]
1252    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1253    where
1254        S: serde::Serializer,
1255    {
1256        use serde::ser::SerializeStruct;
1257        let mut len = 0;
1258        if self.table_id != 0 {
1259            len += 1;
1260        }
1261        if self.resource_group.is_some() {
1262            len += 1;
1263        }
1264        if self.deferred {
1265            len += 1;
1266        }
1267        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1268        if self.table_id != 0 {
1269            struct_ser.serialize_field("tableId", &self.table_id)?;
1270        }
1271        if let Some(v) = self.resource_group.as_ref() {
1272            struct_ser.serialize_field("resourceGroup", v)?;
1273        }
1274        if self.deferred {
1275            struct_ser.serialize_field("deferred", &self.deferred)?;
1276        }
1277        struct_ser.end()
1278    }
1279}
1280impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1281    #[allow(deprecated)]
1282    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1283    where
1284        D: serde::Deserializer<'de>,
1285    {
1286        const FIELDS: &[&str] = &[
1287            "table_id",
1288            "tableId",
1289            "resource_group",
1290            "resourceGroup",
1291            "deferred",
1292        ];
1293
1294        #[allow(clippy::enum_variant_names)]
1295        enum GeneratedField {
1296            TableId,
1297            ResourceGroup,
1298            Deferred,
1299        }
1300        impl<'de> serde::Deserialize<'de> for GeneratedField {
1301            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1302            where
1303                D: serde::Deserializer<'de>,
1304            {
1305                struct GeneratedVisitor;
1306
1307                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1308                    type Value = GeneratedField;
1309
1310                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1311                        write!(formatter, "expected one of: {:?}", &FIELDS)
1312                    }
1313
1314                    #[allow(unused_variables)]
1315                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1316                    where
1317                        E: serde::de::Error,
1318                    {
1319                        match value {
1320                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
1321                            "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1322                            "deferred" => Ok(GeneratedField::Deferred),
1323                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1324                        }
1325                    }
1326                }
1327                deserializer.deserialize_identifier(GeneratedVisitor)
1328            }
1329        }
1330        struct GeneratedVisitor;
1331        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1332            type Value = AlterResourceGroupRequest;
1333
1334            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1335                formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
1336            }
1337
1338            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
1339                where
1340                    V: serde::de::MapAccess<'de>,
1341            {
1342                let mut table_id__ = None;
1343                let mut resource_group__ = None;
1344                let mut deferred__ = None;
1345                while let Some(k) = map_.next_key()? {
1346                    match k {
1347                        GeneratedField::TableId => {
1348                            if table_id__.is_some() {
1349                                return Err(serde::de::Error::duplicate_field("tableId"));
1350                            }
1351                            table_id__ = 
1352                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1353                            ;
1354                        }
1355                        GeneratedField::ResourceGroup => {
1356                            if resource_group__.is_some() {
1357                                return Err(serde::de::Error::duplicate_field("resourceGroup"));
1358                            }
1359                            resource_group__ = map_.next_value()?;
1360                        }
1361                        GeneratedField::Deferred => {
1362                            if deferred__.is_some() {
1363                                return Err(serde::de::Error::duplicate_field("deferred"));
1364                            }
1365                            deferred__ = Some(map_.next_value()?);
1366                        }
1367                    }
1368                }
1369                Ok(AlterResourceGroupRequest {
1370                    table_id: table_id__.unwrap_or_default(),
1371                    resource_group: resource_group__,
1372                    deferred: deferred__.unwrap_or_default(),
1373                })
1374            }
1375        }
1376        deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
1377    }
1378}
1379impl serde::Serialize for AlterResourceGroupResponse {
1380    #[allow(deprecated)]
1381    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1382    where
1383        S: serde::Serializer,
1384    {
1385        use serde::ser::SerializeStruct;
1386        let len = 0;
1387        let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
1388        struct_ser.end()
1389    }
1390}
1391impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
1392    #[allow(deprecated)]
1393    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1394    where
1395        D: serde::Deserializer<'de>,
1396    {
1397        const FIELDS: &[&str] = &[
1398        ];
1399
1400        #[allow(clippy::enum_variant_names)]
1401        enum GeneratedField {
1402        }
1403        impl<'de> serde::Deserialize<'de> for GeneratedField {
1404            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1405            where
1406                D: serde::Deserializer<'de>,
1407            {
1408                struct GeneratedVisitor;
1409
1410                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1411                    type Value = GeneratedField;
1412
1413                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1414                        write!(formatter, "expected one of: {:?}", &FIELDS)
1415                    }
1416
1417                    #[allow(unused_variables)]
1418                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1419                    where
1420                        E: serde::de::Error,
1421                    {
1422                            Err(serde::de::Error::unknown_field(value, FIELDS))
1423                    }
1424                }
1425                deserializer.deserialize_identifier(GeneratedVisitor)
1426            }
1427        }
1428        struct GeneratedVisitor;
1429        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1430            type Value = AlterResourceGroupResponse;
1431
1432            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1433                formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
1434            }
1435
1436            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
1437                where
1438                    V: serde::de::MapAccess<'de>,
1439            {
1440                while map_.next_key::<GeneratedField>()?.is_some() {
1441                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1442                }
1443                Ok(AlterResourceGroupResponse {
1444                })
1445            }
1446        }
1447        deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
1448    }
1449}
1450impl serde::Serialize for AlterSecretRequest {
1451    #[allow(deprecated)]
1452    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1453    where
1454        S: serde::Serializer,
1455    {
1456        use serde::ser::SerializeStruct;
1457        let mut len = 0;
1458        if self.secret_id != 0 {
1459            len += 1;
1460        }
1461        if !self.name.is_empty() {
1462            len += 1;
1463        }
1464        if !self.value.is_empty() {
1465            len += 1;
1466        }
1467        if self.database_id != 0 {
1468            len += 1;
1469        }
1470        if self.schema_id != 0 {
1471            len += 1;
1472        }
1473        if self.owner_id != 0 {
1474            len += 1;
1475        }
1476        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
1477        if self.secret_id != 0 {
1478            struct_ser.serialize_field("secretId", &self.secret_id)?;
1479        }
1480        if !self.name.is_empty() {
1481            struct_ser.serialize_field("name", &self.name)?;
1482        }
1483        if !self.value.is_empty() {
1484            #[allow(clippy::needless_borrow)]
1485            #[allow(clippy::needless_borrows_for_generic_args)]
1486            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
1487        }
1488        if self.database_id != 0 {
1489            struct_ser.serialize_field("databaseId", &self.database_id)?;
1490        }
1491        if self.schema_id != 0 {
1492            struct_ser.serialize_field("schemaId", &self.schema_id)?;
1493        }
1494        if self.owner_id != 0 {
1495            struct_ser.serialize_field("ownerId", &self.owner_id)?;
1496        }
1497        struct_ser.end()
1498    }
1499}
1500impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
1501    #[allow(deprecated)]
1502    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1503    where
1504        D: serde::Deserializer<'de>,
1505    {
1506        const FIELDS: &[&str] = &[
1507            "secret_id",
1508            "secretId",
1509            "name",
1510            "value",
1511            "database_id",
1512            "databaseId",
1513            "schema_id",
1514            "schemaId",
1515            "owner_id",
1516            "ownerId",
1517        ];
1518
1519        #[allow(clippy::enum_variant_names)]
1520        enum GeneratedField {
1521            SecretId,
1522            Name,
1523            Value,
1524            DatabaseId,
1525            SchemaId,
1526            OwnerId,
1527        }
1528        impl<'de> serde::Deserialize<'de> for GeneratedField {
1529            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1530            where
1531                D: serde::Deserializer<'de>,
1532            {
1533                struct GeneratedVisitor;
1534
1535                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1536                    type Value = GeneratedField;
1537
1538                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1539                        write!(formatter, "expected one of: {:?}", &FIELDS)
1540                    }
1541
1542                    #[allow(unused_variables)]
1543                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1544                    where
1545                        E: serde::de::Error,
1546                    {
1547                        match value {
1548                            "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1549                            "name" => Ok(GeneratedField::Name),
1550                            "value" => Ok(GeneratedField::Value),
1551                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1552                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1553                            "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1554                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1555                        }
1556                    }
1557                }
1558                deserializer.deserialize_identifier(GeneratedVisitor)
1559            }
1560        }
1561        struct GeneratedVisitor;
1562        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1563            type Value = AlterSecretRequest;
1564
1565            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1566                formatter.write_str("struct ddl_service.AlterSecretRequest")
1567            }
1568
1569            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
1570                where
1571                    V: serde::de::MapAccess<'de>,
1572            {
1573                let mut secret_id__ = None;
1574                let mut name__ = None;
1575                let mut value__ = None;
1576                let mut database_id__ = None;
1577                let mut schema_id__ = None;
1578                let mut owner_id__ = None;
1579                while let Some(k) = map_.next_key()? {
1580                    match k {
1581                        GeneratedField::SecretId => {
1582                            if secret_id__.is_some() {
1583                                return Err(serde::de::Error::duplicate_field("secretId"));
1584                            }
1585                            secret_id__ = 
1586                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1587                            ;
1588                        }
1589                        GeneratedField::Name => {
1590                            if name__.is_some() {
1591                                return Err(serde::de::Error::duplicate_field("name"));
1592                            }
1593                            name__ = Some(map_.next_value()?);
1594                        }
1595                        GeneratedField::Value => {
1596                            if value__.is_some() {
1597                                return Err(serde::de::Error::duplicate_field("value"));
1598                            }
1599                            value__ = 
1600                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
1601                            ;
1602                        }
1603                        GeneratedField::DatabaseId => {
1604                            if database_id__.is_some() {
1605                                return Err(serde::de::Error::duplicate_field("databaseId"));
1606                            }
1607                            database_id__ = 
1608                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1609                            ;
1610                        }
1611                        GeneratedField::SchemaId => {
1612                            if schema_id__.is_some() {
1613                                return Err(serde::de::Error::duplicate_field("schemaId"));
1614                            }
1615                            schema_id__ = 
1616                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1617                            ;
1618                        }
1619                        GeneratedField::OwnerId => {
1620                            if owner_id__.is_some() {
1621                                return Err(serde::de::Error::duplicate_field("ownerId"));
1622                            }
1623                            owner_id__ = 
1624                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1625                            ;
1626                        }
1627                    }
1628                }
1629                Ok(AlterSecretRequest {
1630                    secret_id: secret_id__.unwrap_or_default(),
1631                    name: name__.unwrap_or_default(),
1632                    value: value__.unwrap_or_default(),
1633                    database_id: database_id__.unwrap_or_default(),
1634                    schema_id: schema_id__.unwrap_or_default(),
1635                    owner_id: owner_id__.unwrap_or_default(),
1636                })
1637            }
1638        }
1639        deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
1640    }
1641}
1642impl serde::Serialize for AlterSecretResponse {
1643    #[allow(deprecated)]
1644    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1645    where
1646        S: serde::Serializer,
1647    {
1648        use serde::ser::SerializeStruct;
1649        let mut len = 0;
1650        if self.version.is_some() {
1651            len += 1;
1652        }
1653        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
1654        if let Some(v) = self.version.as_ref() {
1655            struct_ser.serialize_field("version", v)?;
1656        }
1657        struct_ser.end()
1658    }
1659}
1660impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
1661    #[allow(deprecated)]
1662    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1663    where
1664        D: serde::Deserializer<'de>,
1665    {
1666        const FIELDS: &[&str] = &[
1667            "version",
1668        ];
1669
1670        #[allow(clippy::enum_variant_names)]
1671        enum GeneratedField {
1672            Version,
1673        }
1674        impl<'de> serde::Deserialize<'de> for GeneratedField {
1675            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1676            where
1677                D: serde::Deserializer<'de>,
1678            {
1679                struct GeneratedVisitor;
1680
1681                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1682                    type Value = GeneratedField;
1683
1684                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1685                        write!(formatter, "expected one of: {:?}", &FIELDS)
1686                    }
1687
1688                    #[allow(unused_variables)]
1689                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1690                    where
1691                        E: serde::de::Error,
1692                    {
1693                        match value {
1694                            "version" => Ok(GeneratedField::Version),
1695                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1696                        }
1697                    }
1698                }
1699                deserializer.deserialize_identifier(GeneratedVisitor)
1700            }
1701        }
1702        struct GeneratedVisitor;
1703        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1704            type Value = AlterSecretResponse;
1705
1706            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1707                formatter.write_str("struct ddl_service.AlterSecretResponse")
1708            }
1709
1710            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
1711                where
1712                    V: serde::de::MapAccess<'de>,
1713            {
1714                let mut version__ = None;
1715                while let Some(k) = map_.next_key()? {
1716                    match k {
1717                        GeneratedField::Version => {
1718                            if version__.is_some() {
1719                                return Err(serde::de::Error::duplicate_field("version"));
1720                            }
1721                            version__ = map_.next_value()?;
1722                        }
1723                    }
1724                }
1725                Ok(AlterSecretResponse {
1726                    version: version__,
1727                })
1728            }
1729        }
1730        deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
1731    }
1732}
1733impl serde::Serialize for AlterSetSchemaRequest {
1734    #[allow(deprecated)]
1735    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1736    where
1737        S: serde::Serializer,
1738    {
1739        use serde::ser::SerializeStruct;
1740        let mut len = 0;
1741        if self.new_schema_id != 0 {
1742            len += 1;
1743        }
1744        if self.object.is_some() {
1745            len += 1;
1746        }
1747        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
1748        if self.new_schema_id != 0 {
1749            struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
1750        }
1751        if let Some(v) = self.object.as_ref() {
1752            match v {
1753                alter_set_schema_request::Object::TableId(v) => {
1754                    struct_ser.serialize_field("tableId", v)?;
1755                }
1756                alter_set_schema_request::Object::ViewId(v) => {
1757                    struct_ser.serialize_field("viewId", v)?;
1758                }
1759                alter_set_schema_request::Object::SourceId(v) => {
1760                    struct_ser.serialize_field("sourceId", v)?;
1761                }
1762                alter_set_schema_request::Object::SinkId(v) => {
1763                    struct_ser.serialize_field("sinkId", v)?;
1764                }
1765                alter_set_schema_request::Object::FunctionId(v) => {
1766                    struct_ser.serialize_field("functionId", v)?;
1767                }
1768                alter_set_schema_request::Object::ConnectionId(v) => {
1769                    struct_ser.serialize_field("connectionId", v)?;
1770                }
1771                alter_set_schema_request::Object::SubscriptionId(v) => {
1772                    struct_ser.serialize_field("subscriptionId", v)?;
1773                }
1774            }
1775        }
1776        struct_ser.end()
1777    }
1778}
1779impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
1780    #[allow(deprecated)]
1781    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1782    where
1783        D: serde::Deserializer<'de>,
1784    {
1785        const FIELDS: &[&str] = &[
1786            "new_schema_id",
1787            "newSchemaId",
1788            "table_id",
1789            "tableId",
1790            "view_id",
1791            "viewId",
1792            "source_id",
1793            "sourceId",
1794            "sink_id",
1795            "sinkId",
1796            "function_id",
1797            "functionId",
1798            "connection_id",
1799            "connectionId",
1800            "subscription_id",
1801            "subscriptionId",
1802        ];
1803
1804        #[allow(clippy::enum_variant_names)]
1805        enum GeneratedField {
1806            NewSchemaId,
1807            TableId,
1808            ViewId,
1809            SourceId,
1810            SinkId,
1811            FunctionId,
1812            ConnectionId,
1813            SubscriptionId,
1814        }
1815        impl<'de> serde::Deserialize<'de> for GeneratedField {
1816            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1817            where
1818                D: serde::Deserializer<'de>,
1819            {
1820                struct GeneratedVisitor;
1821
1822                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1823                    type Value = GeneratedField;
1824
1825                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1826                        write!(formatter, "expected one of: {:?}", &FIELDS)
1827                    }
1828
1829                    #[allow(unused_variables)]
1830                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1831                    where
1832                        E: serde::de::Error,
1833                    {
1834                        match value {
1835                            "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
1836                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
1837                            "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1838                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1839                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1840                            "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
1841                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1842                            "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1843                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1844                        }
1845                    }
1846                }
1847                deserializer.deserialize_identifier(GeneratedVisitor)
1848            }
1849        }
1850        struct GeneratedVisitor;
1851        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1852            type Value = AlterSetSchemaRequest;
1853
1854            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1855                formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
1856            }
1857
1858            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
1859                where
1860                    V: serde::de::MapAccess<'de>,
1861            {
1862                let mut new_schema_id__ = None;
1863                let mut object__ = None;
1864                while let Some(k) = map_.next_key()? {
1865                    match k {
1866                        GeneratedField::NewSchemaId => {
1867                            if new_schema_id__.is_some() {
1868                                return Err(serde::de::Error::duplicate_field("newSchemaId"));
1869                            }
1870                            new_schema_id__ = 
1871                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1872                            ;
1873                        }
1874                        GeneratedField::TableId => {
1875                            if object__.is_some() {
1876                                return Err(serde::de::Error::duplicate_field("tableId"));
1877                            }
1878                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
1879                        }
1880                        GeneratedField::ViewId => {
1881                            if object__.is_some() {
1882                                return Err(serde::de::Error::duplicate_field("viewId"));
1883                            }
1884                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
1885                        }
1886                        GeneratedField::SourceId => {
1887                            if object__.is_some() {
1888                                return Err(serde::de::Error::duplicate_field("sourceId"));
1889                            }
1890                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
1891                        }
1892                        GeneratedField::SinkId => {
1893                            if object__.is_some() {
1894                                return Err(serde::de::Error::duplicate_field("sinkId"));
1895                            }
1896                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
1897                        }
1898                        GeneratedField::FunctionId => {
1899                            if object__.is_some() {
1900                                return Err(serde::de::Error::duplicate_field("functionId"));
1901                            }
1902                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
1903                        }
1904                        GeneratedField::ConnectionId => {
1905                            if object__.is_some() {
1906                                return Err(serde::de::Error::duplicate_field("connectionId"));
1907                            }
1908                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
1909                        }
1910                        GeneratedField::SubscriptionId => {
1911                            if object__.is_some() {
1912                                return Err(serde::de::Error::duplicate_field("subscriptionId"));
1913                            }
1914                            object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
1915                        }
1916                    }
1917                }
1918                Ok(AlterSetSchemaRequest {
1919                    new_schema_id: new_schema_id__.unwrap_or_default(),
1920                    object: object__,
1921                })
1922            }
1923        }
1924        deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
1925    }
1926}
1927impl serde::Serialize for AlterSetSchemaResponse {
1928    #[allow(deprecated)]
1929    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1930    where
1931        S: serde::Serializer,
1932    {
1933        use serde::ser::SerializeStruct;
1934        let mut len = 0;
1935        if self.status.is_some() {
1936            len += 1;
1937        }
1938        if self.version.is_some() {
1939            len += 1;
1940        }
1941        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
1942        if let Some(v) = self.status.as_ref() {
1943            struct_ser.serialize_field("status", v)?;
1944        }
1945        if let Some(v) = self.version.as_ref() {
1946            struct_ser.serialize_field("version", v)?;
1947        }
1948        struct_ser.end()
1949    }
1950}
1951impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
1952    #[allow(deprecated)]
1953    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1954    where
1955        D: serde::Deserializer<'de>,
1956    {
1957        const FIELDS: &[&str] = &[
1958            "status",
1959            "version",
1960        ];
1961
1962        #[allow(clippy::enum_variant_names)]
1963        enum GeneratedField {
1964            Status,
1965            Version,
1966        }
1967        impl<'de> serde::Deserialize<'de> for GeneratedField {
1968            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1969            where
1970                D: serde::Deserializer<'de>,
1971            {
1972                struct GeneratedVisitor;
1973
1974                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1975                    type Value = GeneratedField;
1976
1977                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1978                        write!(formatter, "expected one of: {:?}", &FIELDS)
1979                    }
1980
1981                    #[allow(unused_variables)]
1982                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1983                    where
1984                        E: serde::de::Error,
1985                    {
1986                        match value {
1987                            "status" => Ok(GeneratedField::Status),
1988                            "version" => Ok(GeneratedField::Version),
1989                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1990                        }
1991                    }
1992                }
1993                deserializer.deserialize_identifier(GeneratedVisitor)
1994            }
1995        }
1996        struct GeneratedVisitor;
1997        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1998            type Value = AlterSetSchemaResponse;
1999
2000            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2001                formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2002            }
2003
2004            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2005                where
2006                    V: serde::de::MapAccess<'de>,
2007            {
2008                let mut status__ = None;
2009                let mut version__ = None;
2010                while let Some(k) = map_.next_key()? {
2011                    match k {
2012                        GeneratedField::Status => {
2013                            if status__.is_some() {
2014                                return Err(serde::de::Error::duplicate_field("status"));
2015                            }
2016                            status__ = map_.next_value()?;
2017                        }
2018                        GeneratedField::Version => {
2019                            if version__.is_some() {
2020                                return Err(serde::de::Error::duplicate_field("version"));
2021                            }
2022                            version__ = map_.next_value()?;
2023                        }
2024                    }
2025                }
2026                Ok(AlterSetSchemaResponse {
2027                    status: status__,
2028                    version: version__,
2029                })
2030            }
2031        }
2032        deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2033    }
2034}
2035impl serde::Serialize for AlterSourceRequest {
2036    #[allow(deprecated)]
2037    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2038    where
2039        S: serde::Serializer,
2040    {
2041        use serde::ser::SerializeStruct;
2042        let mut len = 0;
2043        if self.source.is_some() {
2044            len += 1;
2045        }
2046        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2047        if let Some(v) = self.source.as_ref() {
2048            struct_ser.serialize_field("source", v)?;
2049        }
2050        struct_ser.end()
2051    }
2052}
2053impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2054    #[allow(deprecated)]
2055    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2056    where
2057        D: serde::Deserializer<'de>,
2058    {
2059        const FIELDS: &[&str] = &[
2060            "source",
2061        ];
2062
2063        #[allow(clippy::enum_variant_names)]
2064        enum GeneratedField {
2065            Source,
2066        }
2067        impl<'de> serde::Deserialize<'de> for GeneratedField {
2068            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2069            where
2070                D: serde::Deserializer<'de>,
2071            {
2072                struct GeneratedVisitor;
2073
2074                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2075                    type Value = GeneratedField;
2076
2077                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2078                        write!(formatter, "expected one of: {:?}", &FIELDS)
2079                    }
2080
2081                    #[allow(unused_variables)]
2082                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2083                    where
2084                        E: serde::de::Error,
2085                    {
2086                        match value {
2087                            "source" => Ok(GeneratedField::Source),
2088                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2089                        }
2090                    }
2091                }
2092                deserializer.deserialize_identifier(GeneratedVisitor)
2093            }
2094        }
2095        struct GeneratedVisitor;
2096        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2097            type Value = AlterSourceRequest;
2098
2099            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2100                formatter.write_str("struct ddl_service.AlterSourceRequest")
2101            }
2102
2103            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2104                where
2105                    V: serde::de::MapAccess<'de>,
2106            {
2107                let mut source__ = None;
2108                while let Some(k) = map_.next_key()? {
2109                    match k {
2110                        GeneratedField::Source => {
2111                            if source__.is_some() {
2112                                return Err(serde::de::Error::duplicate_field("source"));
2113                            }
2114                            source__ = map_.next_value()?;
2115                        }
2116                    }
2117                }
2118                Ok(AlterSourceRequest {
2119                    source: source__,
2120                })
2121            }
2122        }
2123        deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2124    }
2125}
2126impl serde::Serialize for AlterSourceResponse {
2127    #[allow(deprecated)]
2128    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2129    where
2130        S: serde::Serializer,
2131    {
2132        use serde::ser::SerializeStruct;
2133        let mut len = 0;
2134        if self.status.is_some() {
2135            len += 1;
2136        }
2137        if self.version.is_some() {
2138            len += 1;
2139        }
2140        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2141        if let Some(v) = self.status.as_ref() {
2142            struct_ser.serialize_field("status", v)?;
2143        }
2144        if let Some(v) = self.version.as_ref() {
2145            struct_ser.serialize_field("version", v)?;
2146        }
2147        struct_ser.end()
2148    }
2149}
2150impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2151    #[allow(deprecated)]
2152    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2153    where
2154        D: serde::Deserializer<'de>,
2155    {
2156        const FIELDS: &[&str] = &[
2157            "status",
2158            "version",
2159        ];
2160
2161        #[allow(clippy::enum_variant_names)]
2162        enum GeneratedField {
2163            Status,
2164            Version,
2165        }
2166        impl<'de> serde::Deserialize<'de> for GeneratedField {
2167            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2168            where
2169                D: serde::Deserializer<'de>,
2170            {
2171                struct GeneratedVisitor;
2172
2173                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2174                    type Value = GeneratedField;
2175
2176                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2177                        write!(formatter, "expected one of: {:?}", &FIELDS)
2178                    }
2179
2180                    #[allow(unused_variables)]
2181                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2182                    where
2183                        E: serde::de::Error,
2184                    {
2185                        match value {
2186                            "status" => Ok(GeneratedField::Status),
2187                            "version" => Ok(GeneratedField::Version),
2188                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2189                        }
2190                    }
2191                }
2192                deserializer.deserialize_identifier(GeneratedVisitor)
2193            }
2194        }
2195        struct GeneratedVisitor;
2196        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2197            type Value = AlterSourceResponse;
2198
2199            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2200                formatter.write_str("struct ddl_service.AlterSourceResponse")
2201            }
2202
2203            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2204                where
2205                    V: serde::de::MapAccess<'de>,
2206            {
2207                let mut status__ = None;
2208                let mut version__ = None;
2209                while let Some(k) = map_.next_key()? {
2210                    match k {
2211                        GeneratedField::Status => {
2212                            if status__.is_some() {
2213                                return Err(serde::de::Error::duplicate_field("status"));
2214                            }
2215                            status__ = map_.next_value()?;
2216                        }
2217                        GeneratedField::Version => {
2218                            if version__.is_some() {
2219                                return Err(serde::de::Error::duplicate_field("version"));
2220                            }
2221                            version__ = map_.next_value()?;
2222                        }
2223                    }
2224                }
2225                Ok(AlterSourceResponse {
2226                    status: status__,
2227                    version: version__,
2228                })
2229            }
2230        }
2231        deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2232    }
2233}
2234impl serde::Serialize for AlterSwapRenameRequest {
2235    #[allow(deprecated)]
2236    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2237    where
2238        S: serde::Serializer,
2239    {
2240        use serde::ser::SerializeStruct;
2241        let mut len = 0;
2242        if self.object.is_some() {
2243            len += 1;
2244        }
2245        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
2246        if let Some(v) = self.object.as_ref() {
2247            match v {
2248                alter_swap_rename_request::Object::Schema(v) => {
2249                    struct_ser.serialize_field("schema", v)?;
2250                }
2251                alter_swap_rename_request::Object::Table(v) => {
2252                    struct_ser.serialize_field("table", v)?;
2253                }
2254                alter_swap_rename_request::Object::View(v) => {
2255                    struct_ser.serialize_field("view", v)?;
2256                }
2257                alter_swap_rename_request::Object::Source(v) => {
2258                    struct_ser.serialize_field("source", v)?;
2259                }
2260                alter_swap_rename_request::Object::Sink(v) => {
2261                    struct_ser.serialize_field("sink", v)?;
2262                }
2263                alter_swap_rename_request::Object::Subscription(v) => {
2264                    struct_ser.serialize_field("subscription", v)?;
2265                }
2266            }
2267        }
2268        struct_ser.end()
2269    }
2270}
2271impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
2272    #[allow(deprecated)]
2273    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2274    where
2275        D: serde::Deserializer<'de>,
2276    {
2277        const FIELDS: &[&str] = &[
2278            "schema",
2279            "table",
2280            "view",
2281            "source",
2282            "sink",
2283            "subscription",
2284        ];
2285
2286        #[allow(clippy::enum_variant_names)]
2287        enum GeneratedField {
2288            Schema,
2289            Table,
2290            View,
2291            Source,
2292            Sink,
2293            Subscription,
2294        }
2295        impl<'de> serde::Deserialize<'de> for GeneratedField {
2296            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2297            where
2298                D: serde::Deserializer<'de>,
2299            {
2300                struct GeneratedVisitor;
2301
2302                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2303                    type Value = GeneratedField;
2304
2305                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2306                        write!(formatter, "expected one of: {:?}", &FIELDS)
2307                    }
2308
2309                    #[allow(unused_variables)]
2310                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2311                    where
2312                        E: serde::de::Error,
2313                    {
2314                        match value {
2315                            "schema" => Ok(GeneratedField::Schema),
2316                            "table" => Ok(GeneratedField::Table),
2317                            "view" => Ok(GeneratedField::View),
2318                            "source" => Ok(GeneratedField::Source),
2319                            "sink" => Ok(GeneratedField::Sink),
2320                            "subscription" => Ok(GeneratedField::Subscription),
2321                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2322                        }
2323                    }
2324                }
2325                deserializer.deserialize_identifier(GeneratedVisitor)
2326            }
2327        }
2328        struct GeneratedVisitor;
2329        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2330            type Value = AlterSwapRenameRequest;
2331
2332            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2333                formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
2334            }
2335
2336            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
2337                where
2338                    V: serde::de::MapAccess<'de>,
2339            {
2340                let mut object__ = None;
2341                while let Some(k) = map_.next_key()? {
2342                    match k {
2343                        GeneratedField::Schema => {
2344                            if object__.is_some() {
2345                                return Err(serde::de::Error::duplicate_field("schema"));
2346                            }
2347                            object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
2348;
2349                        }
2350                        GeneratedField::Table => {
2351                            if object__.is_some() {
2352                                return Err(serde::de::Error::duplicate_field("table"));
2353                            }
2354                            object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
2355;
2356                        }
2357                        GeneratedField::View => {
2358                            if object__.is_some() {
2359                                return Err(serde::de::Error::duplicate_field("view"));
2360                            }
2361                            object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
2362;
2363                        }
2364                        GeneratedField::Source => {
2365                            if object__.is_some() {
2366                                return Err(serde::de::Error::duplicate_field("source"));
2367                            }
2368                            object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
2369;
2370                        }
2371                        GeneratedField::Sink => {
2372                            if object__.is_some() {
2373                                return Err(serde::de::Error::duplicate_field("sink"));
2374                            }
2375                            object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
2376;
2377                        }
2378                        GeneratedField::Subscription => {
2379                            if object__.is_some() {
2380                                return Err(serde::de::Error::duplicate_field("subscription"));
2381                            }
2382                            object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
2383;
2384                        }
2385                    }
2386                }
2387                Ok(AlterSwapRenameRequest {
2388                    object: object__,
2389                })
2390            }
2391        }
2392        deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
2393    }
2394}
2395impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
2396    #[allow(deprecated)]
2397    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2398    where
2399        S: serde::Serializer,
2400    {
2401        use serde::ser::SerializeStruct;
2402        let mut len = 0;
2403        if self.src_object_id != 0 {
2404            len += 1;
2405        }
2406        if self.dst_object_id != 0 {
2407            len += 1;
2408        }
2409        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
2410        if self.src_object_id != 0 {
2411            struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
2412        }
2413        if self.dst_object_id != 0 {
2414            struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
2415        }
2416        struct_ser.end()
2417    }
2418}
2419impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
2420    #[allow(deprecated)]
2421    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2422    where
2423        D: serde::Deserializer<'de>,
2424    {
2425        const FIELDS: &[&str] = &[
2426            "src_object_id",
2427            "srcObjectId",
2428            "dst_object_id",
2429            "dstObjectId",
2430        ];
2431
2432        #[allow(clippy::enum_variant_names)]
2433        enum GeneratedField {
2434            SrcObjectId,
2435            DstObjectId,
2436        }
2437        impl<'de> serde::Deserialize<'de> for GeneratedField {
2438            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2439            where
2440                D: serde::Deserializer<'de>,
2441            {
2442                struct GeneratedVisitor;
2443
2444                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2445                    type Value = GeneratedField;
2446
2447                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2448                        write!(formatter, "expected one of: {:?}", &FIELDS)
2449                    }
2450
2451                    #[allow(unused_variables)]
2452                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2453                    where
2454                        E: serde::de::Error,
2455                    {
2456                        match value {
2457                            "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
2458                            "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
2459                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2460                        }
2461                    }
2462                }
2463                deserializer.deserialize_identifier(GeneratedVisitor)
2464            }
2465        }
2466        struct GeneratedVisitor;
2467        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2468            type Value = alter_swap_rename_request::ObjectNameSwapPair;
2469
2470            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2471                formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
2472            }
2473
2474            fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
2475                where
2476                    V: serde::de::MapAccess<'de>,
2477            {
2478                let mut src_object_id__ = None;
2479                let mut dst_object_id__ = None;
2480                while let Some(k) = map_.next_key()? {
2481                    match k {
2482                        GeneratedField::SrcObjectId => {
2483                            if src_object_id__.is_some() {
2484                                return Err(serde::de::Error::duplicate_field("srcObjectId"));
2485                            }
2486                            src_object_id__ = 
2487                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2488                            ;
2489                        }
2490                        GeneratedField::DstObjectId => {
2491                            if dst_object_id__.is_some() {
2492                                return Err(serde::de::Error::duplicate_field("dstObjectId"));
2493                            }
2494                            dst_object_id__ = 
2495                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2496                            ;
2497                        }
2498                    }
2499                }
2500                Ok(alter_swap_rename_request::ObjectNameSwapPair {
2501                    src_object_id: src_object_id__.unwrap_or_default(),
2502                    dst_object_id: dst_object_id__.unwrap_or_default(),
2503                })
2504            }
2505        }
2506        deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
2507    }
2508}
2509impl serde::Serialize for AlterSwapRenameResponse {
2510    #[allow(deprecated)]
2511    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2512    where
2513        S: serde::Serializer,
2514    {
2515        use serde::ser::SerializeStruct;
2516        let mut len = 0;
2517        if self.status.is_some() {
2518            len += 1;
2519        }
2520        if self.version.is_some() {
2521            len += 1;
2522        }
2523        let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
2524        if let Some(v) = self.status.as_ref() {
2525            struct_ser.serialize_field("status", v)?;
2526        }
2527        if let Some(v) = self.version.as_ref() {
2528            struct_ser.serialize_field("version", v)?;
2529        }
2530        struct_ser.end()
2531    }
2532}
2533impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
2534    #[allow(deprecated)]
2535    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2536    where
2537        D: serde::Deserializer<'de>,
2538    {
2539        const FIELDS: &[&str] = &[
2540            "status",
2541            "version",
2542        ];
2543
2544        #[allow(clippy::enum_variant_names)]
2545        enum GeneratedField {
2546            Status,
2547            Version,
2548        }
2549        impl<'de> serde::Deserialize<'de> for GeneratedField {
2550            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2551            where
2552                D: serde::Deserializer<'de>,
2553            {
2554                struct GeneratedVisitor;
2555
2556                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2557                    type Value = GeneratedField;
2558
2559                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2560                        write!(formatter, "expected one of: {:?}", &FIELDS)
2561                    }
2562
2563                    #[allow(unused_variables)]
2564                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2565                    where
2566                        E: serde::de::Error,
2567                    {
2568                        match value {
2569                            "status" => Ok(GeneratedField::Status),
2570                            "version" => Ok(GeneratedField::Version),
2571                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2572                        }
2573                    }
2574                }
2575                deserializer.deserialize_identifier(GeneratedVisitor)
2576            }
2577        }
2578        struct GeneratedVisitor;
2579        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2580            type Value = AlterSwapRenameResponse;
2581
2582            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2583                formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
2584            }
2585
2586            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
2587                where
2588                    V: serde::de::MapAccess<'de>,
2589            {
2590                let mut status__ = None;
2591                let mut version__ = None;
2592                while let Some(k) = map_.next_key()? {
2593                    match k {
2594                        GeneratedField::Status => {
2595                            if status__.is_some() {
2596                                return Err(serde::de::Error::duplicate_field("status"));
2597                            }
2598                            status__ = map_.next_value()?;
2599                        }
2600                        GeneratedField::Version => {
2601                            if version__.is_some() {
2602                                return Err(serde::de::Error::duplicate_field("version"));
2603                            }
2604                            version__ = map_.next_value()?;
2605                        }
2606                    }
2607                }
2608                Ok(AlterSwapRenameResponse {
2609                    status: status__,
2610                    version: version__,
2611                })
2612            }
2613        }
2614        deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
2615    }
2616}
2617impl serde::Serialize for AutoSchemaChangeRequest {
2618    #[allow(deprecated)]
2619    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2620    where
2621        S: serde::Serializer,
2622    {
2623        use serde::ser::SerializeStruct;
2624        let mut len = 0;
2625        if self.schema_change.is_some() {
2626            len += 1;
2627        }
2628        let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
2629        if let Some(v) = self.schema_change.as_ref() {
2630            struct_ser.serialize_field("schemaChange", v)?;
2631        }
2632        struct_ser.end()
2633    }
2634}
2635impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
2636    #[allow(deprecated)]
2637    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2638    where
2639        D: serde::Deserializer<'de>,
2640    {
2641        const FIELDS: &[&str] = &[
2642            "schema_change",
2643            "schemaChange",
2644        ];
2645
2646        #[allow(clippy::enum_variant_names)]
2647        enum GeneratedField {
2648            SchemaChange,
2649        }
2650        impl<'de> serde::Deserialize<'de> for GeneratedField {
2651            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2652            where
2653                D: serde::Deserializer<'de>,
2654            {
2655                struct GeneratedVisitor;
2656
2657                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2658                    type Value = GeneratedField;
2659
2660                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2661                        write!(formatter, "expected one of: {:?}", &FIELDS)
2662                    }
2663
2664                    #[allow(unused_variables)]
2665                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2666                    where
2667                        E: serde::de::Error,
2668                    {
2669                        match value {
2670                            "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
2671                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2672                        }
2673                    }
2674                }
2675                deserializer.deserialize_identifier(GeneratedVisitor)
2676            }
2677        }
2678        struct GeneratedVisitor;
2679        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2680            type Value = AutoSchemaChangeRequest;
2681
2682            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2683                formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
2684            }
2685
2686            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
2687                where
2688                    V: serde::de::MapAccess<'de>,
2689            {
2690                let mut schema_change__ = None;
2691                while let Some(k) = map_.next_key()? {
2692                    match k {
2693                        GeneratedField::SchemaChange => {
2694                            if schema_change__.is_some() {
2695                                return Err(serde::de::Error::duplicate_field("schemaChange"));
2696                            }
2697                            schema_change__ = map_.next_value()?;
2698                        }
2699                    }
2700                }
2701                Ok(AutoSchemaChangeRequest {
2702                    schema_change: schema_change__,
2703                })
2704            }
2705        }
2706        deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
2707    }
2708}
2709impl serde::Serialize for AutoSchemaChangeResponse {
2710    #[allow(deprecated)]
2711    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2712    where
2713        S: serde::Serializer,
2714    {
2715        use serde::ser::SerializeStruct;
2716        let len = 0;
2717        let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
2718        struct_ser.end()
2719    }
2720}
2721impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
2722    #[allow(deprecated)]
2723    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2724    where
2725        D: serde::Deserializer<'de>,
2726    {
2727        const FIELDS: &[&str] = &[
2728        ];
2729
2730        #[allow(clippy::enum_variant_names)]
2731        enum GeneratedField {
2732        }
2733        impl<'de> serde::Deserialize<'de> for GeneratedField {
2734            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2735            where
2736                D: serde::Deserializer<'de>,
2737            {
2738                struct GeneratedVisitor;
2739
2740                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2741                    type Value = GeneratedField;
2742
2743                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2744                        write!(formatter, "expected one of: {:?}", &FIELDS)
2745                    }
2746
2747                    #[allow(unused_variables)]
2748                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2749                    where
2750                        E: serde::de::Error,
2751                    {
2752                            Err(serde::de::Error::unknown_field(value, FIELDS))
2753                    }
2754                }
2755                deserializer.deserialize_identifier(GeneratedVisitor)
2756            }
2757        }
2758        struct GeneratedVisitor;
2759        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2760            type Value = AutoSchemaChangeResponse;
2761
2762            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2763                formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
2764            }
2765
2766            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
2767                where
2768                    V: serde::de::MapAccess<'de>,
2769            {
2770                while map_.next_key::<GeneratedField>()?.is_some() {
2771                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2772                }
2773                Ok(AutoSchemaChangeResponse {
2774                })
2775            }
2776        }
2777        deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
2778    }
2779}
2780impl serde::Serialize for CommentOnRequest {
2781    #[allow(deprecated)]
2782    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2783    where
2784        S: serde::Serializer,
2785    {
2786        use serde::ser::SerializeStruct;
2787        let mut len = 0;
2788        if self.comment.is_some() {
2789            len += 1;
2790        }
2791        let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
2792        if let Some(v) = self.comment.as_ref() {
2793            struct_ser.serialize_field("comment", v)?;
2794        }
2795        struct_ser.end()
2796    }
2797}
2798impl<'de> serde::Deserialize<'de> for CommentOnRequest {
2799    #[allow(deprecated)]
2800    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2801    where
2802        D: serde::Deserializer<'de>,
2803    {
2804        const FIELDS: &[&str] = &[
2805            "comment",
2806        ];
2807
2808        #[allow(clippy::enum_variant_names)]
2809        enum GeneratedField {
2810            Comment,
2811        }
2812        impl<'de> serde::Deserialize<'de> for GeneratedField {
2813            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2814            where
2815                D: serde::Deserializer<'de>,
2816            {
2817                struct GeneratedVisitor;
2818
2819                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2820                    type Value = GeneratedField;
2821
2822                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2823                        write!(formatter, "expected one of: {:?}", &FIELDS)
2824                    }
2825
2826                    #[allow(unused_variables)]
2827                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2828                    where
2829                        E: serde::de::Error,
2830                    {
2831                        match value {
2832                            "comment" => Ok(GeneratedField::Comment),
2833                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2834                        }
2835                    }
2836                }
2837                deserializer.deserialize_identifier(GeneratedVisitor)
2838            }
2839        }
2840        struct GeneratedVisitor;
2841        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2842            type Value = CommentOnRequest;
2843
2844            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2845                formatter.write_str("struct ddl_service.CommentOnRequest")
2846            }
2847
2848            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
2849                where
2850                    V: serde::de::MapAccess<'de>,
2851            {
2852                let mut comment__ = None;
2853                while let Some(k) = map_.next_key()? {
2854                    match k {
2855                        GeneratedField::Comment => {
2856                            if comment__.is_some() {
2857                                return Err(serde::de::Error::duplicate_field("comment"));
2858                            }
2859                            comment__ = map_.next_value()?;
2860                        }
2861                    }
2862                }
2863                Ok(CommentOnRequest {
2864                    comment: comment__,
2865                })
2866            }
2867        }
2868        deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
2869    }
2870}
2871impl serde::Serialize for CommentOnResponse {
2872    #[allow(deprecated)]
2873    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2874    where
2875        S: serde::Serializer,
2876    {
2877        use serde::ser::SerializeStruct;
2878        let mut len = 0;
2879        if self.status.is_some() {
2880            len += 1;
2881        }
2882        if self.version.is_some() {
2883            len += 1;
2884        }
2885        let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
2886        if let Some(v) = self.status.as_ref() {
2887            struct_ser.serialize_field("status", v)?;
2888        }
2889        if let Some(v) = self.version.as_ref() {
2890            struct_ser.serialize_field("version", v)?;
2891        }
2892        struct_ser.end()
2893    }
2894}
2895impl<'de> serde::Deserialize<'de> for CommentOnResponse {
2896    #[allow(deprecated)]
2897    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2898    where
2899        D: serde::Deserializer<'de>,
2900    {
2901        const FIELDS: &[&str] = &[
2902            "status",
2903            "version",
2904        ];
2905
2906        #[allow(clippy::enum_variant_names)]
2907        enum GeneratedField {
2908            Status,
2909            Version,
2910        }
2911        impl<'de> serde::Deserialize<'de> for GeneratedField {
2912            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2913            where
2914                D: serde::Deserializer<'de>,
2915            {
2916                struct GeneratedVisitor;
2917
2918                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2919                    type Value = GeneratedField;
2920
2921                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2922                        write!(formatter, "expected one of: {:?}", &FIELDS)
2923                    }
2924
2925                    #[allow(unused_variables)]
2926                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2927                    where
2928                        E: serde::de::Error,
2929                    {
2930                        match value {
2931                            "status" => Ok(GeneratedField::Status),
2932                            "version" => Ok(GeneratedField::Version),
2933                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2934                        }
2935                    }
2936                }
2937                deserializer.deserialize_identifier(GeneratedVisitor)
2938            }
2939        }
2940        struct GeneratedVisitor;
2941        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2942            type Value = CommentOnResponse;
2943
2944            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2945                formatter.write_str("struct ddl_service.CommentOnResponse")
2946            }
2947
2948            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
2949                where
2950                    V: serde::de::MapAccess<'de>,
2951            {
2952                let mut status__ = None;
2953                let mut version__ = None;
2954                while let Some(k) = map_.next_key()? {
2955                    match k {
2956                        GeneratedField::Status => {
2957                            if status__.is_some() {
2958                                return Err(serde::de::Error::duplicate_field("status"));
2959                            }
2960                            status__ = map_.next_value()?;
2961                        }
2962                        GeneratedField::Version => {
2963                            if version__.is_some() {
2964                                return Err(serde::de::Error::duplicate_field("version"));
2965                            }
2966                            version__ = map_.next_value()?;
2967                        }
2968                    }
2969                }
2970                Ok(CommentOnResponse {
2971                    status: status__,
2972                    version: version__,
2973                })
2974            }
2975        }
2976        deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
2977    }
2978}
2979impl serde::Serialize for CompactIcebergTableRequest {
2980    #[allow(deprecated)]
2981    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2982    where
2983        S: serde::Serializer,
2984    {
2985        use serde::ser::SerializeStruct;
2986        let mut len = 0;
2987        if self.sink_id != 0 {
2988            len += 1;
2989        }
2990        let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
2991        if self.sink_id != 0 {
2992            struct_ser.serialize_field("sinkId", &self.sink_id)?;
2993        }
2994        struct_ser.end()
2995    }
2996}
2997impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
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            "sink_id",
3005            "sinkId",
3006        ];
3007
3008        #[allow(clippy::enum_variant_names)]
3009        enum GeneratedField {
3010            SinkId,
3011        }
3012        impl<'de> serde::Deserialize<'de> for GeneratedField {
3013            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3014            where
3015                D: serde::Deserializer<'de>,
3016            {
3017                struct GeneratedVisitor;
3018
3019                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3020                    type Value = GeneratedField;
3021
3022                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3023                        write!(formatter, "expected one of: {:?}", &FIELDS)
3024                    }
3025
3026                    #[allow(unused_variables)]
3027                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3028                    where
3029                        E: serde::de::Error,
3030                    {
3031                        match value {
3032                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
3033                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3034                        }
3035                    }
3036                }
3037                deserializer.deserialize_identifier(GeneratedVisitor)
3038            }
3039        }
3040        struct GeneratedVisitor;
3041        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3042            type Value = CompactIcebergTableRequest;
3043
3044            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3045                formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
3046            }
3047
3048            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
3049                where
3050                    V: serde::de::MapAccess<'de>,
3051            {
3052                let mut sink_id__ = None;
3053                while let Some(k) = map_.next_key()? {
3054                    match k {
3055                        GeneratedField::SinkId => {
3056                            if sink_id__.is_some() {
3057                                return Err(serde::de::Error::duplicate_field("sinkId"));
3058                            }
3059                            sink_id__ = 
3060                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3061                            ;
3062                        }
3063                    }
3064                }
3065                Ok(CompactIcebergTableRequest {
3066                    sink_id: sink_id__.unwrap_or_default(),
3067                })
3068            }
3069        }
3070        deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
3071    }
3072}
3073impl serde::Serialize for CompactIcebergTableResponse {
3074    #[allow(deprecated)]
3075    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3076    where
3077        S: serde::Serializer,
3078    {
3079        use serde::ser::SerializeStruct;
3080        let mut len = 0;
3081        if self.status.is_some() {
3082            len += 1;
3083        }
3084        if self.task_id != 0 {
3085            len += 1;
3086        }
3087        let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
3088        if let Some(v) = self.status.as_ref() {
3089            struct_ser.serialize_field("status", v)?;
3090        }
3091        if self.task_id != 0 {
3092            #[allow(clippy::needless_borrow)]
3093            #[allow(clippy::needless_borrows_for_generic_args)]
3094            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
3095        }
3096        struct_ser.end()
3097    }
3098}
3099impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
3100    #[allow(deprecated)]
3101    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3102    where
3103        D: serde::Deserializer<'de>,
3104    {
3105        const FIELDS: &[&str] = &[
3106            "status",
3107            "task_id",
3108            "taskId",
3109        ];
3110
3111        #[allow(clippy::enum_variant_names)]
3112        enum GeneratedField {
3113            Status,
3114            TaskId,
3115        }
3116        impl<'de> serde::Deserialize<'de> for GeneratedField {
3117            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3118            where
3119                D: serde::Deserializer<'de>,
3120            {
3121                struct GeneratedVisitor;
3122
3123                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3124                    type Value = GeneratedField;
3125
3126                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3127                        write!(formatter, "expected one of: {:?}", &FIELDS)
3128                    }
3129
3130                    #[allow(unused_variables)]
3131                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3132                    where
3133                        E: serde::de::Error,
3134                    {
3135                        match value {
3136                            "status" => Ok(GeneratedField::Status),
3137                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
3138                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3139                        }
3140                    }
3141                }
3142                deserializer.deserialize_identifier(GeneratedVisitor)
3143            }
3144        }
3145        struct GeneratedVisitor;
3146        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3147            type Value = CompactIcebergTableResponse;
3148
3149            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3150                formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
3151            }
3152
3153            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
3154                where
3155                    V: serde::de::MapAccess<'de>,
3156            {
3157                let mut status__ = None;
3158                let mut task_id__ = None;
3159                while let Some(k) = map_.next_key()? {
3160                    match k {
3161                        GeneratedField::Status => {
3162                            if status__.is_some() {
3163                                return Err(serde::de::Error::duplicate_field("status"));
3164                            }
3165                            status__ = map_.next_value()?;
3166                        }
3167                        GeneratedField::TaskId => {
3168                            if task_id__.is_some() {
3169                                return Err(serde::de::Error::duplicate_field("taskId"));
3170                            }
3171                            task_id__ = 
3172                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3173                            ;
3174                        }
3175                    }
3176                }
3177                Ok(CompactIcebergTableResponse {
3178                    status: status__,
3179                    task_id: task_id__.unwrap_or_default(),
3180                })
3181            }
3182        }
3183        deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
3184    }
3185}
3186impl serde::Serialize for CreateConnectionRequest {
3187    #[allow(deprecated)]
3188    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3189    where
3190        S: serde::Serializer,
3191    {
3192        use serde::ser::SerializeStruct;
3193        let mut len = 0;
3194        if !self.name.is_empty() {
3195            len += 1;
3196        }
3197        if self.database_id != 0 {
3198            len += 1;
3199        }
3200        if self.schema_id != 0 {
3201            len += 1;
3202        }
3203        if self.owner_id != 0 {
3204            len += 1;
3205        }
3206        if self.payload.is_some() {
3207            len += 1;
3208        }
3209        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
3210        if !self.name.is_empty() {
3211            struct_ser.serialize_field("name", &self.name)?;
3212        }
3213        if self.database_id != 0 {
3214            struct_ser.serialize_field("databaseId", &self.database_id)?;
3215        }
3216        if self.schema_id != 0 {
3217            struct_ser.serialize_field("schemaId", &self.schema_id)?;
3218        }
3219        if self.owner_id != 0 {
3220            struct_ser.serialize_field("ownerId", &self.owner_id)?;
3221        }
3222        if let Some(v) = self.payload.as_ref() {
3223            match v {
3224                create_connection_request::Payload::PrivateLink(v) => {
3225                    struct_ser.serialize_field("privateLink", v)?;
3226                }
3227                create_connection_request::Payload::ConnectionParams(v) => {
3228                    struct_ser.serialize_field("connectionParams", v)?;
3229                }
3230            }
3231        }
3232        struct_ser.end()
3233    }
3234}
3235impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
3236    #[allow(deprecated)]
3237    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3238    where
3239        D: serde::Deserializer<'de>,
3240    {
3241        const FIELDS: &[&str] = &[
3242            "name",
3243            "database_id",
3244            "databaseId",
3245            "schema_id",
3246            "schemaId",
3247            "owner_id",
3248            "ownerId",
3249            "private_link",
3250            "privateLink",
3251            "connection_params",
3252            "connectionParams",
3253        ];
3254
3255        #[allow(clippy::enum_variant_names)]
3256        enum GeneratedField {
3257            Name,
3258            DatabaseId,
3259            SchemaId,
3260            OwnerId,
3261            PrivateLink,
3262            ConnectionParams,
3263        }
3264        impl<'de> serde::Deserialize<'de> for GeneratedField {
3265            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3266            where
3267                D: serde::Deserializer<'de>,
3268            {
3269                struct GeneratedVisitor;
3270
3271                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3272                    type Value = GeneratedField;
3273
3274                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3275                        write!(formatter, "expected one of: {:?}", &FIELDS)
3276                    }
3277
3278                    #[allow(unused_variables)]
3279                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3280                    where
3281                        E: serde::de::Error,
3282                    {
3283                        match value {
3284                            "name" => Ok(GeneratedField::Name),
3285                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3286                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3287                            "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
3288                            "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
3289                            "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
3290                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3291                        }
3292                    }
3293                }
3294                deserializer.deserialize_identifier(GeneratedVisitor)
3295            }
3296        }
3297        struct GeneratedVisitor;
3298        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3299            type Value = CreateConnectionRequest;
3300
3301            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3302                formatter.write_str("struct ddl_service.CreateConnectionRequest")
3303            }
3304
3305            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
3306                where
3307                    V: serde::de::MapAccess<'de>,
3308            {
3309                let mut name__ = None;
3310                let mut database_id__ = None;
3311                let mut schema_id__ = None;
3312                let mut owner_id__ = None;
3313                let mut payload__ = None;
3314                while let Some(k) = map_.next_key()? {
3315                    match k {
3316                        GeneratedField::Name => {
3317                            if name__.is_some() {
3318                                return Err(serde::de::Error::duplicate_field("name"));
3319                            }
3320                            name__ = Some(map_.next_value()?);
3321                        }
3322                        GeneratedField::DatabaseId => {
3323                            if database_id__.is_some() {
3324                                return Err(serde::de::Error::duplicate_field("databaseId"));
3325                            }
3326                            database_id__ = 
3327                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3328                            ;
3329                        }
3330                        GeneratedField::SchemaId => {
3331                            if schema_id__.is_some() {
3332                                return Err(serde::de::Error::duplicate_field("schemaId"));
3333                            }
3334                            schema_id__ = 
3335                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3336                            ;
3337                        }
3338                        GeneratedField::OwnerId => {
3339                            if owner_id__.is_some() {
3340                                return Err(serde::de::Error::duplicate_field("ownerId"));
3341                            }
3342                            owner_id__ = 
3343                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3344                            ;
3345                        }
3346                        GeneratedField::PrivateLink => {
3347                            if payload__.is_some() {
3348                                return Err(serde::de::Error::duplicate_field("privateLink"));
3349                            }
3350                            payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
3351;
3352                        }
3353                        GeneratedField::ConnectionParams => {
3354                            if payload__.is_some() {
3355                                return Err(serde::de::Error::duplicate_field("connectionParams"));
3356                            }
3357                            payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
3358;
3359                        }
3360                    }
3361                }
3362                Ok(CreateConnectionRequest {
3363                    name: name__.unwrap_or_default(),
3364                    database_id: database_id__.unwrap_or_default(),
3365                    schema_id: schema_id__.unwrap_or_default(),
3366                    owner_id: owner_id__.unwrap_or_default(),
3367                    payload: payload__,
3368                })
3369            }
3370        }
3371        deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
3372    }
3373}
3374impl serde::Serialize for create_connection_request::PrivateLink {
3375    #[allow(deprecated)]
3376    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3377    where
3378        S: serde::Serializer,
3379    {
3380        use serde::ser::SerializeStruct;
3381        let mut len = 0;
3382        if self.provider != 0 {
3383            len += 1;
3384        }
3385        if !self.service_name.is_empty() {
3386            len += 1;
3387        }
3388        if self.tags.is_some() {
3389            len += 1;
3390        }
3391        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
3392        if self.provider != 0 {
3393            let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
3394                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
3395            struct_ser.serialize_field("provider", &v)?;
3396        }
3397        if !self.service_name.is_empty() {
3398            struct_ser.serialize_field("serviceName", &self.service_name)?;
3399        }
3400        if let Some(v) = self.tags.as_ref() {
3401            struct_ser.serialize_field("tags", v)?;
3402        }
3403        struct_ser.end()
3404    }
3405}
3406impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
3407    #[allow(deprecated)]
3408    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3409    where
3410        D: serde::Deserializer<'de>,
3411    {
3412        const FIELDS: &[&str] = &[
3413            "provider",
3414            "service_name",
3415            "serviceName",
3416            "tags",
3417        ];
3418
3419        #[allow(clippy::enum_variant_names)]
3420        enum GeneratedField {
3421            Provider,
3422            ServiceName,
3423            Tags,
3424        }
3425        impl<'de> serde::Deserialize<'de> for GeneratedField {
3426            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3427            where
3428                D: serde::Deserializer<'de>,
3429            {
3430                struct GeneratedVisitor;
3431
3432                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3433                    type Value = GeneratedField;
3434
3435                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3436                        write!(formatter, "expected one of: {:?}", &FIELDS)
3437                    }
3438
3439                    #[allow(unused_variables)]
3440                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3441                    where
3442                        E: serde::de::Error,
3443                    {
3444                        match value {
3445                            "provider" => Ok(GeneratedField::Provider),
3446                            "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
3447                            "tags" => Ok(GeneratedField::Tags),
3448                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3449                        }
3450                    }
3451                }
3452                deserializer.deserialize_identifier(GeneratedVisitor)
3453            }
3454        }
3455        struct GeneratedVisitor;
3456        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3457            type Value = create_connection_request::PrivateLink;
3458
3459            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3460                formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
3461            }
3462
3463            fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
3464                where
3465                    V: serde::de::MapAccess<'de>,
3466            {
3467                let mut provider__ = None;
3468                let mut service_name__ = None;
3469                let mut tags__ = None;
3470                while let Some(k) = map_.next_key()? {
3471                    match k {
3472                        GeneratedField::Provider => {
3473                            if provider__.is_some() {
3474                                return Err(serde::de::Error::duplicate_field("provider"));
3475                            }
3476                            provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
3477                        }
3478                        GeneratedField::ServiceName => {
3479                            if service_name__.is_some() {
3480                                return Err(serde::de::Error::duplicate_field("serviceName"));
3481                            }
3482                            service_name__ = Some(map_.next_value()?);
3483                        }
3484                        GeneratedField::Tags => {
3485                            if tags__.is_some() {
3486                                return Err(serde::de::Error::duplicate_field("tags"));
3487                            }
3488                            tags__ = map_.next_value()?;
3489                        }
3490                    }
3491                }
3492                Ok(create_connection_request::PrivateLink {
3493                    provider: provider__.unwrap_or_default(),
3494                    service_name: service_name__.unwrap_or_default(),
3495                    tags: tags__,
3496                })
3497            }
3498        }
3499        deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
3500    }
3501}
3502impl serde::Serialize for CreateConnectionResponse {
3503    #[allow(deprecated)]
3504    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3505    where
3506        S: serde::Serializer,
3507    {
3508        use serde::ser::SerializeStruct;
3509        let mut len = 0;
3510        if self.version.is_some() {
3511            len += 1;
3512        }
3513        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
3514        if let Some(v) = self.version.as_ref() {
3515            struct_ser.serialize_field("version", v)?;
3516        }
3517        struct_ser.end()
3518    }
3519}
3520impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
3521    #[allow(deprecated)]
3522    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3523    where
3524        D: serde::Deserializer<'de>,
3525    {
3526        const FIELDS: &[&str] = &[
3527            "version",
3528        ];
3529
3530        #[allow(clippy::enum_variant_names)]
3531        enum GeneratedField {
3532            Version,
3533        }
3534        impl<'de> serde::Deserialize<'de> for GeneratedField {
3535            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3536            where
3537                D: serde::Deserializer<'de>,
3538            {
3539                struct GeneratedVisitor;
3540
3541                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3542                    type Value = GeneratedField;
3543
3544                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3545                        write!(formatter, "expected one of: {:?}", &FIELDS)
3546                    }
3547
3548                    #[allow(unused_variables)]
3549                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3550                    where
3551                        E: serde::de::Error,
3552                    {
3553                        match value {
3554                            "version" => Ok(GeneratedField::Version),
3555                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3556                        }
3557                    }
3558                }
3559                deserializer.deserialize_identifier(GeneratedVisitor)
3560            }
3561        }
3562        struct GeneratedVisitor;
3563        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3564            type Value = CreateConnectionResponse;
3565
3566            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3567                formatter.write_str("struct ddl_service.CreateConnectionResponse")
3568            }
3569
3570            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
3571                where
3572                    V: serde::de::MapAccess<'de>,
3573            {
3574                let mut version__ = None;
3575                while let Some(k) = map_.next_key()? {
3576                    match k {
3577                        GeneratedField::Version => {
3578                            if version__.is_some() {
3579                                return Err(serde::de::Error::duplicate_field("version"));
3580                            }
3581                            version__ = map_.next_value()?;
3582                        }
3583                    }
3584                }
3585                Ok(CreateConnectionResponse {
3586                    version: version__,
3587                })
3588            }
3589        }
3590        deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
3591    }
3592}
3593impl serde::Serialize for CreateDatabaseRequest {
3594    #[allow(deprecated)]
3595    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3596    where
3597        S: serde::Serializer,
3598    {
3599        use serde::ser::SerializeStruct;
3600        let mut len = 0;
3601        if self.db.is_some() {
3602            len += 1;
3603        }
3604        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
3605        if let Some(v) = self.db.as_ref() {
3606            struct_ser.serialize_field("db", v)?;
3607        }
3608        struct_ser.end()
3609    }
3610}
3611impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
3612    #[allow(deprecated)]
3613    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3614    where
3615        D: serde::Deserializer<'de>,
3616    {
3617        const FIELDS: &[&str] = &[
3618            "db",
3619        ];
3620
3621        #[allow(clippy::enum_variant_names)]
3622        enum GeneratedField {
3623            Db,
3624        }
3625        impl<'de> serde::Deserialize<'de> for GeneratedField {
3626            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3627            where
3628                D: serde::Deserializer<'de>,
3629            {
3630                struct GeneratedVisitor;
3631
3632                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3633                    type Value = GeneratedField;
3634
3635                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3636                        write!(formatter, "expected one of: {:?}", &FIELDS)
3637                    }
3638
3639                    #[allow(unused_variables)]
3640                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3641                    where
3642                        E: serde::de::Error,
3643                    {
3644                        match value {
3645                            "db" => Ok(GeneratedField::Db),
3646                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3647                        }
3648                    }
3649                }
3650                deserializer.deserialize_identifier(GeneratedVisitor)
3651            }
3652        }
3653        struct GeneratedVisitor;
3654        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3655            type Value = CreateDatabaseRequest;
3656
3657            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3658                formatter.write_str("struct ddl_service.CreateDatabaseRequest")
3659            }
3660
3661            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
3662                where
3663                    V: serde::de::MapAccess<'de>,
3664            {
3665                let mut db__ = None;
3666                while let Some(k) = map_.next_key()? {
3667                    match k {
3668                        GeneratedField::Db => {
3669                            if db__.is_some() {
3670                                return Err(serde::de::Error::duplicate_field("db"));
3671                            }
3672                            db__ = map_.next_value()?;
3673                        }
3674                    }
3675                }
3676                Ok(CreateDatabaseRequest {
3677                    db: db__,
3678                })
3679            }
3680        }
3681        deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
3682    }
3683}
3684impl serde::Serialize for CreateDatabaseResponse {
3685    #[allow(deprecated)]
3686    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3687    where
3688        S: serde::Serializer,
3689    {
3690        use serde::ser::SerializeStruct;
3691        let mut len = 0;
3692        if self.status.is_some() {
3693            len += 1;
3694        }
3695        if self.version.is_some() {
3696            len += 1;
3697        }
3698        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
3699        if let Some(v) = self.status.as_ref() {
3700            struct_ser.serialize_field("status", v)?;
3701        }
3702        if let Some(v) = self.version.as_ref() {
3703            struct_ser.serialize_field("version", v)?;
3704        }
3705        struct_ser.end()
3706    }
3707}
3708impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
3709    #[allow(deprecated)]
3710    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3711    where
3712        D: serde::Deserializer<'de>,
3713    {
3714        const FIELDS: &[&str] = &[
3715            "status",
3716            "version",
3717        ];
3718
3719        #[allow(clippy::enum_variant_names)]
3720        enum GeneratedField {
3721            Status,
3722            Version,
3723        }
3724        impl<'de> serde::Deserialize<'de> for GeneratedField {
3725            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3726            where
3727                D: serde::Deserializer<'de>,
3728            {
3729                struct GeneratedVisitor;
3730
3731                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3732                    type Value = GeneratedField;
3733
3734                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3735                        write!(formatter, "expected one of: {:?}", &FIELDS)
3736                    }
3737
3738                    #[allow(unused_variables)]
3739                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3740                    where
3741                        E: serde::de::Error,
3742                    {
3743                        match value {
3744                            "status" => Ok(GeneratedField::Status),
3745                            "version" => Ok(GeneratedField::Version),
3746                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3747                        }
3748                    }
3749                }
3750                deserializer.deserialize_identifier(GeneratedVisitor)
3751            }
3752        }
3753        struct GeneratedVisitor;
3754        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3755            type Value = CreateDatabaseResponse;
3756
3757            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3758                formatter.write_str("struct ddl_service.CreateDatabaseResponse")
3759            }
3760
3761            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
3762                where
3763                    V: serde::de::MapAccess<'de>,
3764            {
3765                let mut status__ = None;
3766                let mut version__ = None;
3767                while let Some(k) = map_.next_key()? {
3768                    match k {
3769                        GeneratedField::Status => {
3770                            if status__.is_some() {
3771                                return Err(serde::de::Error::duplicate_field("status"));
3772                            }
3773                            status__ = map_.next_value()?;
3774                        }
3775                        GeneratedField::Version => {
3776                            if version__.is_some() {
3777                                return Err(serde::de::Error::duplicate_field("version"));
3778                            }
3779                            version__ = map_.next_value()?;
3780                        }
3781                    }
3782                }
3783                Ok(CreateDatabaseResponse {
3784                    status: status__,
3785                    version: version__,
3786                })
3787            }
3788        }
3789        deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
3790    }
3791}
3792impl serde::Serialize for CreateFunctionRequest {
3793    #[allow(deprecated)]
3794    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3795    where
3796        S: serde::Serializer,
3797    {
3798        use serde::ser::SerializeStruct;
3799        let mut len = 0;
3800        if self.function.is_some() {
3801            len += 1;
3802        }
3803        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
3804        if let Some(v) = self.function.as_ref() {
3805            struct_ser.serialize_field("function", v)?;
3806        }
3807        struct_ser.end()
3808    }
3809}
3810impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
3811    #[allow(deprecated)]
3812    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3813    where
3814        D: serde::Deserializer<'de>,
3815    {
3816        const FIELDS: &[&str] = &[
3817            "function",
3818        ];
3819
3820        #[allow(clippy::enum_variant_names)]
3821        enum GeneratedField {
3822            Function,
3823        }
3824        impl<'de> serde::Deserialize<'de> for GeneratedField {
3825            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3826            where
3827                D: serde::Deserializer<'de>,
3828            {
3829                struct GeneratedVisitor;
3830
3831                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3832                    type Value = GeneratedField;
3833
3834                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3835                        write!(formatter, "expected one of: {:?}", &FIELDS)
3836                    }
3837
3838                    #[allow(unused_variables)]
3839                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3840                    where
3841                        E: serde::de::Error,
3842                    {
3843                        match value {
3844                            "function" => Ok(GeneratedField::Function),
3845                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3846                        }
3847                    }
3848                }
3849                deserializer.deserialize_identifier(GeneratedVisitor)
3850            }
3851        }
3852        struct GeneratedVisitor;
3853        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3854            type Value = CreateFunctionRequest;
3855
3856            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3857                formatter.write_str("struct ddl_service.CreateFunctionRequest")
3858            }
3859
3860            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
3861                where
3862                    V: serde::de::MapAccess<'de>,
3863            {
3864                let mut function__ = None;
3865                while let Some(k) = map_.next_key()? {
3866                    match k {
3867                        GeneratedField::Function => {
3868                            if function__.is_some() {
3869                                return Err(serde::de::Error::duplicate_field("function"));
3870                            }
3871                            function__ = map_.next_value()?;
3872                        }
3873                    }
3874                }
3875                Ok(CreateFunctionRequest {
3876                    function: function__,
3877                })
3878            }
3879        }
3880        deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
3881    }
3882}
3883impl serde::Serialize for CreateFunctionResponse {
3884    #[allow(deprecated)]
3885    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3886    where
3887        S: serde::Serializer,
3888    {
3889        use serde::ser::SerializeStruct;
3890        let mut len = 0;
3891        if self.status.is_some() {
3892            len += 1;
3893        }
3894        if self.version.is_some() {
3895            len += 1;
3896        }
3897        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
3898        if let Some(v) = self.status.as_ref() {
3899            struct_ser.serialize_field("status", v)?;
3900        }
3901        if let Some(v) = self.version.as_ref() {
3902            struct_ser.serialize_field("version", v)?;
3903        }
3904        struct_ser.end()
3905    }
3906}
3907impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
3908    #[allow(deprecated)]
3909    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3910    where
3911        D: serde::Deserializer<'de>,
3912    {
3913        const FIELDS: &[&str] = &[
3914            "status",
3915            "version",
3916        ];
3917
3918        #[allow(clippy::enum_variant_names)]
3919        enum GeneratedField {
3920            Status,
3921            Version,
3922        }
3923        impl<'de> serde::Deserialize<'de> for GeneratedField {
3924            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3925            where
3926                D: serde::Deserializer<'de>,
3927            {
3928                struct GeneratedVisitor;
3929
3930                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3931                    type Value = GeneratedField;
3932
3933                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3934                        write!(formatter, "expected one of: {:?}", &FIELDS)
3935                    }
3936
3937                    #[allow(unused_variables)]
3938                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3939                    where
3940                        E: serde::de::Error,
3941                    {
3942                        match value {
3943                            "status" => Ok(GeneratedField::Status),
3944                            "version" => Ok(GeneratedField::Version),
3945                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3946                        }
3947                    }
3948                }
3949                deserializer.deserialize_identifier(GeneratedVisitor)
3950            }
3951        }
3952        struct GeneratedVisitor;
3953        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3954            type Value = CreateFunctionResponse;
3955
3956            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3957                formatter.write_str("struct ddl_service.CreateFunctionResponse")
3958            }
3959
3960            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
3961                where
3962                    V: serde::de::MapAccess<'de>,
3963            {
3964                let mut status__ = None;
3965                let mut version__ = None;
3966                while let Some(k) = map_.next_key()? {
3967                    match k {
3968                        GeneratedField::Status => {
3969                            if status__.is_some() {
3970                                return Err(serde::de::Error::duplicate_field("status"));
3971                            }
3972                            status__ = map_.next_value()?;
3973                        }
3974                        GeneratedField::Version => {
3975                            if version__.is_some() {
3976                                return Err(serde::de::Error::duplicate_field("version"));
3977                            }
3978                            version__ = map_.next_value()?;
3979                        }
3980                    }
3981                }
3982                Ok(CreateFunctionResponse {
3983                    status: status__,
3984                    version: version__,
3985                })
3986            }
3987        }
3988        deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
3989    }
3990}
3991impl serde::Serialize for CreateIndexRequest {
3992    #[allow(deprecated)]
3993    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3994    where
3995        S: serde::Serializer,
3996    {
3997        use serde::ser::SerializeStruct;
3998        let mut len = 0;
3999        if self.index.is_some() {
4000            len += 1;
4001        }
4002        if self.index_table.is_some() {
4003            len += 1;
4004        }
4005        if self.fragment_graph.is_some() {
4006            len += 1;
4007        }
4008        if self.if_not_exists {
4009            len += 1;
4010        }
4011        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
4012        if let Some(v) = self.index.as_ref() {
4013            struct_ser.serialize_field("index", v)?;
4014        }
4015        if let Some(v) = self.index_table.as_ref() {
4016            struct_ser.serialize_field("indexTable", v)?;
4017        }
4018        if let Some(v) = self.fragment_graph.as_ref() {
4019            struct_ser.serialize_field("fragmentGraph", v)?;
4020        }
4021        if self.if_not_exists {
4022            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4023        }
4024        struct_ser.end()
4025    }
4026}
4027impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
4028    #[allow(deprecated)]
4029    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4030    where
4031        D: serde::Deserializer<'de>,
4032    {
4033        const FIELDS: &[&str] = &[
4034            "index",
4035            "index_table",
4036            "indexTable",
4037            "fragment_graph",
4038            "fragmentGraph",
4039            "if_not_exists",
4040            "ifNotExists",
4041        ];
4042
4043        #[allow(clippy::enum_variant_names)]
4044        enum GeneratedField {
4045            Index,
4046            IndexTable,
4047            FragmentGraph,
4048            IfNotExists,
4049        }
4050        impl<'de> serde::Deserialize<'de> for GeneratedField {
4051            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4052            where
4053                D: serde::Deserializer<'de>,
4054            {
4055                struct GeneratedVisitor;
4056
4057                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4058                    type Value = GeneratedField;
4059
4060                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4061                        write!(formatter, "expected one of: {:?}", &FIELDS)
4062                    }
4063
4064                    #[allow(unused_variables)]
4065                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4066                    where
4067                        E: serde::de::Error,
4068                    {
4069                        match value {
4070                            "index" => Ok(GeneratedField::Index),
4071                            "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
4072                            "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4073                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
4074                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4075                        }
4076                    }
4077                }
4078                deserializer.deserialize_identifier(GeneratedVisitor)
4079            }
4080        }
4081        struct GeneratedVisitor;
4082        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4083            type Value = CreateIndexRequest;
4084
4085            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4086                formatter.write_str("struct ddl_service.CreateIndexRequest")
4087            }
4088
4089            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
4090                where
4091                    V: serde::de::MapAccess<'de>,
4092            {
4093                let mut index__ = None;
4094                let mut index_table__ = None;
4095                let mut fragment_graph__ = None;
4096                let mut if_not_exists__ = None;
4097                while let Some(k) = map_.next_key()? {
4098                    match k {
4099                        GeneratedField::Index => {
4100                            if index__.is_some() {
4101                                return Err(serde::de::Error::duplicate_field("index"));
4102                            }
4103                            index__ = map_.next_value()?;
4104                        }
4105                        GeneratedField::IndexTable => {
4106                            if index_table__.is_some() {
4107                                return Err(serde::de::Error::duplicate_field("indexTable"));
4108                            }
4109                            index_table__ = map_.next_value()?;
4110                        }
4111                        GeneratedField::FragmentGraph => {
4112                            if fragment_graph__.is_some() {
4113                                return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4114                            }
4115                            fragment_graph__ = map_.next_value()?;
4116                        }
4117                        GeneratedField::IfNotExists => {
4118                            if if_not_exists__.is_some() {
4119                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
4120                            }
4121                            if_not_exists__ = Some(map_.next_value()?);
4122                        }
4123                    }
4124                }
4125                Ok(CreateIndexRequest {
4126                    index: index__,
4127                    index_table: index_table__,
4128                    fragment_graph: fragment_graph__,
4129                    if_not_exists: if_not_exists__.unwrap_or_default(),
4130                })
4131            }
4132        }
4133        deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
4134    }
4135}
4136impl serde::Serialize for CreateIndexResponse {
4137    #[allow(deprecated)]
4138    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4139    where
4140        S: serde::Serializer,
4141    {
4142        use serde::ser::SerializeStruct;
4143        let mut len = 0;
4144        if self.status.is_some() {
4145            len += 1;
4146        }
4147        if self.version.is_some() {
4148            len += 1;
4149        }
4150        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
4151        if let Some(v) = self.status.as_ref() {
4152            struct_ser.serialize_field("status", v)?;
4153        }
4154        if let Some(v) = self.version.as_ref() {
4155            struct_ser.serialize_field("version", v)?;
4156        }
4157        struct_ser.end()
4158    }
4159}
4160impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
4161    #[allow(deprecated)]
4162    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4163    where
4164        D: serde::Deserializer<'de>,
4165    {
4166        const FIELDS: &[&str] = &[
4167            "status",
4168            "version",
4169        ];
4170
4171        #[allow(clippy::enum_variant_names)]
4172        enum GeneratedField {
4173            Status,
4174            Version,
4175        }
4176        impl<'de> serde::Deserialize<'de> for GeneratedField {
4177            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4178            where
4179                D: serde::Deserializer<'de>,
4180            {
4181                struct GeneratedVisitor;
4182
4183                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4184                    type Value = GeneratedField;
4185
4186                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4187                        write!(formatter, "expected one of: {:?}", &FIELDS)
4188                    }
4189
4190                    #[allow(unused_variables)]
4191                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4192                    where
4193                        E: serde::de::Error,
4194                    {
4195                        match value {
4196                            "status" => Ok(GeneratedField::Status),
4197                            "version" => Ok(GeneratedField::Version),
4198                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4199                        }
4200                    }
4201                }
4202                deserializer.deserialize_identifier(GeneratedVisitor)
4203            }
4204        }
4205        struct GeneratedVisitor;
4206        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4207            type Value = CreateIndexResponse;
4208
4209            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4210                formatter.write_str("struct ddl_service.CreateIndexResponse")
4211            }
4212
4213            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
4214                where
4215                    V: serde::de::MapAccess<'de>,
4216            {
4217                let mut status__ = None;
4218                let mut version__ = None;
4219                while let Some(k) = map_.next_key()? {
4220                    match k {
4221                        GeneratedField::Status => {
4222                            if status__.is_some() {
4223                                return Err(serde::de::Error::duplicate_field("status"));
4224                            }
4225                            status__ = map_.next_value()?;
4226                        }
4227                        GeneratedField::Version => {
4228                            if version__.is_some() {
4229                                return Err(serde::de::Error::duplicate_field("version"));
4230                            }
4231                            version__ = map_.next_value()?;
4232                        }
4233                    }
4234                }
4235                Ok(CreateIndexResponse {
4236                    status: status__,
4237                    version: version__,
4238                })
4239            }
4240        }
4241        deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
4242    }
4243}
4244impl serde::Serialize for CreateMaterializedViewRequest {
4245    #[allow(deprecated)]
4246    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4247    where
4248        S: serde::Serializer,
4249    {
4250        use serde::ser::SerializeStruct;
4251        let mut len = 0;
4252        if self.materialized_view.is_some() {
4253            len += 1;
4254        }
4255        if self.fragment_graph.is_some() {
4256            len += 1;
4257        }
4258        if self.backfill != 0 {
4259            len += 1;
4260        }
4261        if !self.dependencies.is_empty() {
4262            len += 1;
4263        }
4264        if self.specific_resource_group.is_some() {
4265            len += 1;
4266        }
4267        if self.if_not_exists {
4268            len += 1;
4269        }
4270        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
4271        if let Some(v) = self.materialized_view.as_ref() {
4272            struct_ser.serialize_field("materializedView", v)?;
4273        }
4274        if let Some(v) = self.fragment_graph.as_ref() {
4275            struct_ser.serialize_field("fragmentGraph", v)?;
4276        }
4277        if self.backfill != 0 {
4278            let v = create_materialized_view_request::BackfillType::try_from(self.backfill)
4279                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill)))?;
4280            struct_ser.serialize_field("backfill", &v)?;
4281        }
4282        if !self.dependencies.is_empty() {
4283            struct_ser.serialize_field("dependencies", &self.dependencies)?;
4284        }
4285        if let Some(v) = self.specific_resource_group.as_ref() {
4286            struct_ser.serialize_field("specificResourceGroup", v)?;
4287        }
4288        if self.if_not_exists {
4289            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4290        }
4291        struct_ser.end()
4292    }
4293}
4294impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
4295    #[allow(deprecated)]
4296    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4297    where
4298        D: serde::Deserializer<'de>,
4299    {
4300        const FIELDS: &[&str] = &[
4301            "materialized_view",
4302            "materializedView",
4303            "fragment_graph",
4304            "fragmentGraph",
4305            "backfill",
4306            "dependencies",
4307            "specific_resource_group",
4308            "specificResourceGroup",
4309            "if_not_exists",
4310            "ifNotExists",
4311        ];
4312
4313        #[allow(clippy::enum_variant_names)]
4314        enum GeneratedField {
4315            MaterializedView,
4316            FragmentGraph,
4317            Backfill,
4318            Dependencies,
4319            SpecificResourceGroup,
4320            IfNotExists,
4321        }
4322        impl<'de> serde::Deserialize<'de> for GeneratedField {
4323            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4324            where
4325                D: serde::Deserializer<'de>,
4326            {
4327                struct GeneratedVisitor;
4328
4329                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4330                    type Value = GeneratedField;
4331
4332                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4333                        write!(formatter, "expected one of: {:?}", &FIELDS)
4334                    }
4335
4336                    #[allow(unused_variables)]
4337                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4338                    where
4339                        E: serde::de::Error,
4340                    {
4341                        match value {
4342                            "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
4343                            "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4344                            "backfill" => Ok(GeneratedField::Backfill),
4345                            "dependencies" => Ok(GeneratedField::Dependencies),
4346                            "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
4347                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
4348                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4349                        }
4350                    }
4351                }
4352                deserializer.deserialize_identifier(GeneratedVisitor)
4353            }
4354        }
4355        struct GeneratedVisitor;
4356        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4357            type Value = CreateMaterializedViewRequest;
4358
4359            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4360                formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
4361            }
4362
4363            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
4364                where
4365                    V: serde::de::MapAccess<'de>,
4366            {
4367                let mut materialized_view__ = None;
4368                let mut fragment_graph__ = None;
4369                let mut backfill__ = None;
4370                let mut dependencies__ = None;
4371                let mut specific_resource_group__ = None;
4372                let mut if_not_exists__ = None;
4373                while let Some(k) = map_.next_key()? {
4374                    match k {
4375                        GeneratedField::MaterializedView => {
4376                            if materialized_view__.is_some() {
4377                                return Err(serde::de::Error::duplicate_field("materializedView"));
4378                            }
4379                            materialized_view__ = map_.next_value()?;
4380                        }
4381                        GeneratedField::FragmentGraph => {
4382                            if fragment_graph__.is_some() {
4383                                return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4384                            }
4385                            fragment_graph__ = map_.next_value()?;
4386                        }
4387                        GeneratedField::Backfill => {
4388                            if backfill__.is_some() {
4389                                return Err(serde::de::Error::duplicate_field("backfill"));
4390                            }
4391                            backfill__ = Some(map_.next_value::<create_materialized_view_request::BackfillType>()? as i32);
4392                        }
4393                        GeneratedField::Dependencies => {
4394                            if dependencies__.is_some() {
4395                                return Err(serde::de::Error::duplicate_field("dependencies"));
4396                            }
4397                            dependencies__ = 
4398                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4399                                    .into_iter().map(|x| x.0).collect())
4400                            ;
4401                        }
4402                        GeneratedField::SpecificResourceGroup => {
4403                            if specific_resource_group__.is_some() {
4404                                return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
4405                            }
4406                            specific_resource_group__ = map_.next_value()?;
4407                        }
4408                        GeneratedField::IfNotExists => {
4409                            if if_not_exists__.is_some() {
4410                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
4411                            }
4412                            if_not_exists__ = Some(map_.next_value()?);
4413                        }
4414                    }
4415                }
4416                Ok(CreateMaterializedViewRequest {
4417                    materialized_view: materialized_view__,
4418                    fragment_graph: fragment_graph__,
4419                    backfill: backfill__.unwrap_or_default(),
4420                    dependencies: dependencies__.unwrap_or_default(),
4421                    specific_resource_group: specific_resource_group__,
4422                    if_not_exists: if_not_exists__.unwrap_or_default(),
4423                })
4424            }
4425        }
4426        deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
4427    }
4428}
4429impl serde::Serialize for create_materialized_view_request::BackfillType {
4430    #[allow(deprecated)]
4431    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4432    where
4433        S: serde::Serializer,
4434    {
4435        let variant = match self {
4436            Self::Unspecified => "UNSPECIFIED",
4437            Self::Regular => "REGULAR",
4438            Self::Serverless => "SERVERLESS",
4439        };
4440        serializer.serialize_str(variant)
4441    }
4442}
4443impl<'de> serde::Deserialize<'de> for create_materialized_view_request::BackfillType {
4444    #[allow(deprecated)]
4445    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4446    where
4447        D: serde::Deserializer<'de>,
4448    {
4449        const FIELDS: &[&str] = &[
4450            "UNSPECIFIED",
4451            "REGULAR",
4452            "SERVERLESS",
4453        ];
4454
4455        struct GeneratedVisitor;
4456
4457        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4458            type Value = create_materialized_view_request::BackfillType;
4459
4460            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4461                write!(formatter, "expected one of: {:?}", &FIELDS)
4462            }
4463
4464            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4465            where
4466                E: serde::de::Error,
4467            {
4468                i32::try_from(v)
4469                    .ok()
4470                    .and_then(|x| x.try_into().ok())
4471                    .ok_or_else(|| {
4472                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4473                    })
4474            }
4475
4476            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4477            where
4478                E: serde::de::Error,
4479            {
4480                i32::try_from(v)
4481                    .ok()
4482                    .and_then(|x| x.try_into().ok())
4483                    .ok_or_else(|| {
4484                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4485                    })
4486            }
4487
4488            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4489            where
4490                E: serde::de::Error,
4491            {
4492                match value {
4493                    "UNSPECIFIED" => Ok(create_materialized_view_request::BackfillType::Unspecified),
4494                    "REGULAR" => Ok(create_materialized_view_request::BackfillType::Regular),
4495                    "SERVERLESS" => Ok(create_materialized_view_request::BackfillType::Serverless),
4496                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4497                }
4498            }
4499        }
4500        deserializer.deserialize_any(GeneratedVisitor)
4501    }
4502}
4503impl serde::Serialize for CreateMaterializedViewResponse {
4504    #[allow(deprecated)]
4505    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4506    where
4507        S: serde::Serializer,
4508    {
4509        use serde::ser::SerializeStruct;
4510        let mut len = 0;
4511        if self.status.is_some() {
4512            len += 1;
4513        }
4514        if self.version.is_some() {
4515            len += 1;
4516        }
4517        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
4518        if let Some(v) = self.status.as_ref() {
4519            struct_ser.serialize_field("status", v)?;
4520        }
4521        if let Some(v) = self.version.as_ref() {
4522            struct_ser.serialize_field("version", v)?;
4523        }
4524        struct_ser.end()
4525    }
4526}
4527impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
4528    #[allow(deprecated)]
4529    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4530    where
4531        D: serde::Deserializer<'de>,
4532    {
4533        const FIELDS: &[&str] = &[
4534            "status",
4535            "version",
4536        ];
4537
4538        #[allow(clippy::enum_variant_names)]
4539        enum GeneratedField {
4540            Status,
4541            Version,
4542        }
4543        impl<'de> serde::Deserialize<'de> for GeneratedField {
4544            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4545            where
4546                D: serde::Deserializer<'de>,
4547            {
4548                struct GeneratedVisitor;
4549
4550                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4551                    type Value = GeneratedField;
4552
4553                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4554                        write!(formatter, "expected one of: {:?}", &FIELDS)
4555                    }
4556
4557                    #[allow(unused_variables)]
4558                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4559                    where
4560                        E: serde::de::Error,
4561                    {
4562                        match value {
4563                            "status" => Ok(GeneratedField::Status),
4564                            "version" => Ok(GeneratedField::Version),
4565                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4566                        }
4567                    }
4568                }
4569                deserializer.deserialize_identifier(GeneratedVisitor)
4570            }
4571        }
4572        struct GeneratedVisitor;
4573        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4574            type Value = CreateMaterializedViewResponse;
4575
4576            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4577                formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
4578            }
4579
4580            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
4581                where
4582                    V: serde::de::MapAccess<'de>,
4583            {
4584                let mut status__ = None;
4585                let mut version__ = None;
4586                while let Some(k) = map_.next_key()? {
4587                    match k {
4588                        GeneratedField::Status => {
4589                            if status__.is_some() {
4590                                return Err(serde::de::Error::duplicate_field("status"));
4591                            }
4592                            status__ = map_.next_value()?;
4593                        }
4594                        GeneratedField::Version => {
4595                            if version__.is_some() {
4596                                return Err(serde::de::Error::duplicate_field("version"));
4597                            }
4598                            version__ = map_.next_value()?;
4599                        }
4600                    }
4601                }
4602                Ok(CreateMaterializedViewResponse {
4603                    status: status__,
4604                    version: version__,
4605                })
4606            }
4607        }
4608        deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
4609    }
4610}
4611impl serde::Serialize for CreateSchemaRequest {
4612    #[allow(deprecated)]
4613    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4614    where
4615        S: serde::Serializer,
4616    {
4617        use serde::ser::SerializeStruct;
4618        let mut len = 0;
4619        if self.schema.is_some() {
4620            len += 1;
4621        }
4622        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
4623        if let Some(v) = self.schema.as_ref() {
4624            struct_ser.serialize_field("schema", v)?;
4625        }
4626        struct_ser.end()
4627    }
4628}
4629impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
4630    #[allow(deprecated)]
4631    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4632    where
4633        D: serde::Deserializer<'de>,
4634    {
4635        const FIELDS: &[&str] = &[
4636            "schema",
4637        ];
4638
4639        #[allow(clippy::enum_variant_names)]
4640        enum GeneratedField {
4641            Schema,
4642        }
4643        impl<'de> serde::Deserialize<'de> for GeneratedField {
4644            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4645            where
4646                D: serde::Deserializer<'de>,
4647            {
4648                struct GeneratedVisitor;
4649
4650                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4651                    type Value = GeneratedField;
4652
4653                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4654                        write!(formatter, "expected one of: {:?}", &FIELDS)
4655                    }
4656
4657                    #[allow(unused_variables)]
4658                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4659                    where
4660                        E: serde::de::Error,
4661                    {
4662                        match value {
4663                            "schema" => Ok(GeneratedField::Schema),
4664                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4665                        }
4666                    }
4667                }
4668                deserializer.deserialize_identifier(GeneratedVisitor)
4669            }
4670        }
4671        struct GeneratedVisitor;
4672        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4673            type Value = CreateSchemaRequest;
4674
4675            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4676                formatter.write_str("struct ddl_service.CreateSchemaRequest")
4677            }
4678
4679            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
4680                where
4681                    V: serde::de::MapAccess<'de>,
4682            {
4683                let mut schema__ = None;
4684                while let Some(k) = map_.next_key()? {
4685                    match k {
4686                        GeneratedField::Schema => {
4687                            if schema__.is_some() {
4688                                return Err(serde::de::Error::duplicate_field("schema"));
4689                            }
4690                            schema__ = map_.next_value()?;
4691                        }
4692                    }
4693                }
4694                Ok(CreateSchemaRequest {
4695                    schema: schema__,
4696                })
4697            }
4698        }
4699        deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
4700    }
4701}
4702impl serde::Serialize for CreateSchemaResponse {
4703    #[allow(deprecated)]
4704    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4705    where
4706        S: serde::Serializer,
4707    {
4708        use serde::ser::SerializeStruct;
4709        let mut len = 0;
4710        if self.status.is_some() {
4711            len += 1;
4712        }
4713        if self.version.is_some() {
4714            len += 1;
4715        }
4716        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
4717        if let Some(v) = self.status.as_ref() {
4718            struct_ser.serialize_field("status", v)?;
4719        }
4720        if let Some(v) = self.version.as_ref() {
4721            struct_ser.serialize_field("version", v)?;
4722        }
4723        struct_ser.end()
4724    }
4725}
4726impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
4727    #[allow(deprecated)]
4728    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4729    where
4730        D: serde::Deserializer<'de>,
4731    {
4732        const FIELDS: &[&str] = &[
4733            "status",
4734            "version",
4735        ];
4736
4737        #[allow(clippy::enum_variant_names)]
4738        enum GeneratedField {
4739            Status,
4740            Version,
4741        }
4742        impl<'de> serde::Deserialize<'de> for GeneratedField {
4743            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4744            where
4745                D: serde::Deserializer<'de>,
4746            {
4747                struct GeneratedVisitor;
4748
4749                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4750                    type Value = GeneratedField;
4751
4752                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4753                        write!(formatter, "expected one of: {:?}", &FIELDS)
4754                    }
4755
4756                    #[allow(unused_variables)]
4757                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4758                    where
4759                        E: serde::de::Error,
4760                    {
4761                        match value {
4762                            "status" => Ok(GeneratedField::Status),
4763                            "version" => Ok(GeneratedField::Version),
4764                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4765                        }
4766                    }
4767                }
4768                deserializer.deserialize_identifier(GeneratedVisitor)
4769            }
4770        }
4771        struct GeneratedVisitor;
4772        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4773            type Value = CreateSchemaResponse;
4774
4775            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4776                formatter.write_str("struct ddl_service.CreateSchemaResponse")
4777            }
4778
4779            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
4780                where
4781                    V: serde::de::MapAccess<'de>,
4782            {
4783                let mut status__ = None;
4784                let mut version__ = None;
4785                while let Some(k) = map_.next_key()? {
4786                    match k {
4787                        GeneratedField::Status => {
4788                            if status__.is_some() {
4789                                return Err(serde::de::Error::duplicate_field("status"));
4790                            }
4791                            status__ = map_.next_value()?;
4792                        }
4793                        GeneratedField::Version => {
4794                            if version__.is_some() {
4795                                return Err(serde::de::Error::duplicate_field("version"));
4796                            }
4797                            version__ = map_.next_value()?;
4798                        }
4799                    }
4800                }
4801                Ok(CreateSchemaResponse {
4802                    status: status__,
4803                    version: version__,
4804                })
4805            }
4806        }
4807        deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
4808    }
4809}
4810impl serde::Serialize for CreateSecretRequest {
4811    #[allow(deprecated)]
4812    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4813    where
4814        S: serde::Serializer,
4815    {
4816        use serde::ser::SerializeStruct;
4817        let mut len = 0;
4818        if !self.name.is_empty() {
4819            len += 1;
4820        }
4821        if !self.value.is_empty() {
4822            len += 1;
4823        }
4824        if self.database_id != 0 {
4825            len += 1;
4826        }
4827        if self.schema_id != 0 {
4828            len += 1;
4829        }
4830        if self.owner_id != 0 {
4831            len += 1;
4832        }
4833        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
4834        if !self.name.is_empty() {
4835            struct_ser.serialize_field("name", &self.name)?;
4836        }
4837        if !self.value.is_empty() {
4838            #[allow(clippy::needless_borrow)]
4839            #[allow(clippy::needless_borrows_for_generic_args)]
4840            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
4841        }
4842        if self.database_id != 0 {
4843            struct_ser.serialize_field("databaseId", &self.database_id)?;
4844        }
4845        if self.schema_id != 0 {
4846            struct_ser.serialize_field("schemaId", &self.schema_id)?;
4847        }
4848        if self.owner_id != 0 {
4849            struct_ser.serialize_field("ownerId", &self.owner_id)?;
4850        }
4851        struct_ser.end()
4852    }
4853}
4854impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
4855    #[allow(deprecated)]
4856    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4857    where
4858        D: serde::Deserializer<'de>,
4859    {
4860        const FIELDS: &[&str] = &[
4861            "name",
4862            "value",
4863            "database_id",
4864            "databaseId",
4865            "schema_id",
4866            "schemaId",
4867            "owner_id",
4868            "ownerId",
4869        ];
4870
4871        #[allow(clippy::enum_variant_names)]
4872        enum GeneratedField {
4873            Name,
4874            Value,
4875            DatabaseId,
4876            SchemaId,
4877            OwnerId,
4878        }
4879        impl<'de> serde::Deserialize<'de> for GeneratedField {
4880            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4881            where
4882                D: serde::Deserializer<'de>,
4883            {
4884                struct GeneratedVisitor;
4885
4886                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4887                    type Value = GeneratedField;
4888
4889                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4890                        write!(formatter, "expected one of: {:?}", &FIELDS)
4891                    }
4892
4893                    #[allow(unused_variables)]
4894                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4895                    where
4896                        E: serde::de::Error,
4897                    {
4898                        match value {
4899                            "name" => Ok(GeneratedField::Name),
4900                            "value" => Ok(GeneratedField::Value),
4901                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4902                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4903                            "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
4904                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4905                        }
4906                    }
4907                }
4908                deserializer.deserialize_identifier(GeneratedVisitor)
4909            }
4910        }
4911        struct GeneratedVisitor;
4912        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4913            type Value = CreateSecretRequest;
4914
4915            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4916                formatter.write_str("struct ddl_service.CreateSecretRequest")
4917            }
4918
4919            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
4920                where
4921                    V: serde::de::MapAccess<'de>,
4922            {
4923                let mut name__ = None;
4924                let mut value__ = None;
4925                let mut database_id__ = None;
4926                let mut schema_id__ = None;
4927                let mut owner_id__ = None;
4928                while let Some(k) = map_.next_key()? {
4929                    match k {
4930                        GeneratedField::Name => {
4931                            if name__.is_some() {
4932                                return Err(serde::de::Error::duplicate_field("name"));
4933                            }
4934                            name__ = Some(map_.next_value()?);
4935                        }
4936                        GeneratedField::Value => {
4937                            if value__.is_some() {
4938                                return Err(serde::de::Error::duplicate_field("value"));
4939                            }
4940                            value__ = 
4941                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
4942                            ;
4943                        }
4944                        GeneratedField::DatabaseId => {
4945                            if database_id__.is_some() {
4946                                return Err(serde::de::Error::duplicate_field("databaseId"));
4947                            }
4948                            database_id__ = 
4949                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4950                            ;
4951                        }
4952                        GeneratedField::SchemaId => {
4953                            if schema_id__.is_some() {
4954                                return Err(serde::de::Error::duplicate_field("schemaId"));
4955                            }
4956                            schema_id__ = 
4957                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4958                            ;
4959                        }
4960                        GeneratedField::OwnerId => {
4961                            if owner_id__.is_some() {
4962                                return Err(serde::de::Error::duplicate_field("ownerId"));
4963                            }
4964                            owner_id__ = 
4965                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4966                            ;
4967                        }
4968                    }
4969                }
4970                Ok(CreateSecretRequest {
4971                    name: name__.unwrap_or_default(),
4972                    value: value__.unwrap_or_default(),
4973                    database_id: database_id__.unwrap_or_default(),
4974                    schema_id: schema_id__.unwrap_or_default(),
4975                    owner_id: owner_id__.unwrap_or_default(),
4976                })
4977            }
4978        }
4979        deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
4980    }
4981}
4982impl serde::Serialize for CreateSecretResponse {
4983    #[allow(deprecated)]
4984    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4985    where
4986        S: serde::Serializer,
4987    {
4988        use serde::ser::SerializeStruct;
4989        let mut len = 0;
4990        if self.version.is_some() {
4991            len += 1;
4992        }
4993        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
4994        if let Some(v) = self.version.as_ref() {
4995            struct_ser.serialize_field("version", v)?;
4996        }
4997        struct_ser.end()
4998    }
4999}
5000impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
5001    #[allow(deprecated)]
5002    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5003    where
5004        D: serde::Deserializer<'de>,
5005    {
5006        const FIELDS: &[&str] = &[
5007            "version",
5008        ];
5009
5010        #[allow(clippy::enum_variant_names)]
5011        enum GeneratedField {
5012            Version,
5013        }
5014        impl<'de> serde::Deserialize<'de> for GeneratedField {
5015            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5016            where
5017                D: serde::Deserializer<'de>,
5018            {
5019                struct GeneratedVisitor;
5020
5021                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5022                    type Value = GeneratedField;
5023
5024                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5025                        write!(formatter, "expected one of: {:?}", &FIELDS)
5026                    }
5027
5028                    #[allow(unused_variables)]
5029                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5030                    where
5031                        E: serde::de::Error,
5032                    {
5033                        match value {
5034                            "version" => Ok(GeneratedField::Version),
5035                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5036                        }
5037                    }
5038                }
5039                deserializer.deserialize_identifier(GeneratedVisitor)
5040            }
5041        }
5042        struct GeneratedVisitor;
5043        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5044            type Value = CreateSecretResponse;
5045
5046            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5047                formatter.write_str("struct ddl_service.CreateSecretResponse")
5048            }
5049
5050            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
5051                where
5052                    V: serde::de::MapAccess<'de>,
5053            {
5054                let mut version__ = None;
5055                while let Some(k) = map_.next_key()? {
5056                    match k {
5057                        GeneratedField::Version => {
5058                            if version__.is_some() {
5059                                return Err(serde::de::Error::duplicate_field("version"));
5060                            }
5061                            version__ = map_.next_value()?;
5062                        }
5063                    }
5064                }
5065                Ok(CreateSecretResponse {
5066                    version: version__,
5067                })
5068            }
5069        }
5070        deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
5071    }
5072}
5073impl serde::Serialize for CreateSinkRequest {
5074    #[allow(deprecated)]
5075    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5076    where
5077        S: serde::Serializer,
5078    {
5079        use serde::ser::SerializeStruct;
5080        let mut len = 0;
5081        if self.sink.is_some() {
5082            len += 1;
5083        }
5084        if self.fragment_graph.is_some() {
5085            len += 1;
5086        }
5087        if !self.dependencies.is_empty() {
5088            len += 1;
5089        }
5090        if self.if_not_exists {
5091            len += 1;
5092        }
5093        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
5094        if let Some(v) = self.sink.as_ref() {
5095            struct_ser.serialize_field("sink", v)?;
5096        }
5097        if let Some(v) = self.fragment_graph.as_ref() {
5098            struct_ser.serialize_field("fragmentGraph", v)?;
5099        }
5100        if !self.dependencies.is_empty() {
5101            struct_ser.serialize_field("dependencies", &self.dependencies)?;
5102        }
5103        if self.if_not_exists {
5104            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5105        }
5106        struct_ser.end()
5107    }
5108}
5109impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
5110    #[allow(deprecated)]
5111    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5112    where
5113        D: serde::Deserializer<'de>,
5114    {
5115        const FIELDS: &[&str] = &[
5116            "sink",
5117            "fragment_graph",
5118            "fragmentGraph",
5119            "dependencies",
5120            "if_not_exists",
5121            "ifNotExists",
5122        ];
5123
5124        #[allow(clippy::enum_variant_names)]
5125        enum GeneratedField {
5126            Sink,
5127            FragmentGraph,
5128            Dependencies,
5129            IfNotExists,
5130        }
5131        impl<'de> serde::Deserialize<'de> for GeneratedField {
5132            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5133            where
5134                D: serde::Deserializer<'de>,
5135            {
5136                struct GeneratedVisitor;
5137
5138                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5139                    type Value = GeneratedField;
5140
5141                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5142                        write!(formatter, "expected one of: {:?}", &FIELDS)
5143                    }
5144
5145                    #[allow(unused_variables)]
5146                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5147                    where
5148                        E: serde::de::Error,
5149                    {
5150                        match value {
5151                            "sink" => Ok(GeneratedField::Sink),
5152                            "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5153                            "dependencies" => Ok(GeneratedField::Dependencies),
5154                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5155                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5156                        }
5157                    }
5158                }
5159                deserializer.deserialize_identifier(GeneratedVisitor)
5160            }
5161        }
5162        struct GeneratedVisitor;
5163        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5164            type Value = CreateSinkRequest;
5165
5166            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5167                formatter.write_str("struct ddl_service.CreateSinkRequest")
5168            }
5169
5170            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
5171                where
5172                    V: serde::de::MapAccess<'de>,
5173            {
5174                let mut sink__ = None;
5175                let mut fragment_graph__ = None;
5176                let mut dependencies__ = None;
5177                let mut if_not_exists__ = None;
5178                while let Some(k) = map_.next_key()? {
5179                    match k {
5180                        GeneratedField::Sink => {
5181                            if sink__.is_some() {
5182                                return Err(serde::de::Error::duplicate_field("sink"));
5183                            }
5184                            sink__ = map_.next_value()?;
5185                        }
5186                        GeneratedField::FragmentGraph => {
5187                            if fragment_graph__.is_some() {
5188                                return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5189                            }
5190                            fragment_graph__ = map_.next_value()?;
5191                        }
5192                        GeneratedField::Dependencies => {
5193                            if dependencies__.is_some() {
5194                                return Err(serde::de::Error::duplicate_field("dependencies"));
5195                            }
5196                            dependencies__ = 
5197                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5198                                    .into_iter().map(|x| x.0).collect())
5199                            ;
5200                        }
5201                        GeneratedField::IfNotExists => {
5202                            if if_not_exists__.is_some() {
5203                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
5204                            }
5205                            if_not_exists__ = Some(map_.next_value()?);
5206                        }
5207                    }
5208                }
5209                Ok(CreateSinkRequest {
5210                    sink: sink__,
5211                    fragment_graph: fragment_graph__,
5212                    dependencies: dependencies__.unwrap_or_default(),
5213                    if_not_exists: if_not_exists__.unwrap_or_default(),
5214                })
5215            }
5216        }
5217        deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
5218    }
5219}
5220impl serde::Serialize for CreateSinkResponse {
5221    #[allow(deprecated)]
5222    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5223    where
5224        S: serde::Serializer,
5225    {
5226        use serde::ser::SerializeStruct;
5227        let mut len = 0;
5228        if self.status.is_some() {
5229            len += 1;
5230        }
5231        if self.version.is_some() {
5232            len += 1;
5233        }
5234        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
5235        if let Some(v) = self.status.as_ref() {
5236            struct_ser.serialize_field("status", v)?;
5237        }
5238        if let Some(v) = self.version.as_ref() {
5239            struct_ser.serialize_field("version", v)?;
5240        }
5241        struct_ser.end()
5242    }
5243}
5244impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
5245    #[allow(deprecated)]
5246    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5247    where
5248        D: serde::Deserializer<'de>,
5249    {
5250        const FIELDS: &[&str] = &[
5251            "status",
5252            "version",
5253        ];
5254
5255        #[allow(clippy::enum_variant_names)]
5256        enum GeneratedField {
5257            Status,
5258            Version,
5259        }
5260        impl<'de> serde::Deserialize<'de> for GeneratedField {
5261            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5262            where
5263                D: serde::Deserializer<'de>,
5264            {
5265                struct GeneratedVisitor;
5266
5267                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5268                    type Value = GeneratedField;
5269
5270                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5271                        write!(formatter, "expected one of: {:?}", &FIELDS)
5272                    }
5273
5274                    #[allow(unused_variables)]
5275                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5276                    where
5277                        E: serde::de::Error,
5278                    {
5279                        match value {
5280                            "status" => Ok(GeneratedField::Status),
5281                            "version" => Ok(GeneratedField::Version),
5282                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5283                        }
5284                    }
5285                }
5286                deserializer.deserialize_identifier(GeneratedVisitor)
5287            }
5288        }
5289        struct GeneratedVisitor;
5290        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5291            type Value = CreateSinkResponse;
5292
5293            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5294                formatter.write_str("struct ddl_service.CreateSinkResponse")
5295            }
5296
5297            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
5298                where
5299                    V: serde::de::MapAccess<'de>,
5300            {
5301                let mut status__ = None;
5302                let mut version__ = None;
5303                while let Some(k) = map_.next_key()? {
5304                    match k {
5305                        GeneratedField::Status => {
5306                            if status__.is_some() {
5307                                return Err(serde::de::Error::duplicate_field("status"));
5308                            }
5309                            status__ = map_.next_value()?;
5310                        }
5311                        GeneratedField::Version => {
5312                            if version__.is_some() {
5313                                return Err(serde::de::Error::duplicate_field("version"));
5314                            }
5315                            version__ = map_.next_value()?;
5316                        }
5317                    }
5318                }
5319                Ok(CreateSinkResponse {
5320                    status: status__,
5321                    version: version__,
5322                })
5323            }
5324        }
5325        deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
5326    }
5327}
5328impl serde::Serialize for CreateSourceRequest {
5329    #[allow(deprecated)]
5330    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5331    where
5332        S: serde::Serializer,
5333    {
5334        use serde::ser::SerializeStruct;
5335        let mut len = 0;
5336        if self.source.is_some() {
5337            len += 1;
5338        }
5339        if self.fragment_graph.is_some() {
5340            len += 1;
5341        }
5342        if self.if_not_exists {
5343            len += 1;
5344        }
5345        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
5346        if let Some(v) = self.source.as_ref() {
5347            struct_ser.serialize_field("source", v)?;
5348        }
5349        if let Some(v) = self.fragment_graph.as_ref() {
5350            struct_ser.serialize_field("fragmentGraph", v)?;
5351        }
5352        if self.if_not_exists {
5353            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5354        }
5355        struct_ser.end()
5356    }
5357}
5358impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
5359    #[allow(deprecated)]
5360    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5361    where
5362        D: serde::Deserializer<'de>,
5363    {
5364        const FIELDS: &[&str] = &[
5365            "source",
5366            "fragment_graph",
5367            "fragmentGraph",
5368            "if_not_exists",
5369            "ifNotExists",
5370        ];
5371
5372        #[allow(clippy::enum_variant_names)]
5373        enum GeneratedField {
5374            Source,
5375            FragmentGraph,
5376            IfNotExists,
5377        }
5378        impl<'de> serde::Deserialize<'de> for GeneratedField {
5379            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5380            where
5381                D: serde::Deserializer<'de>,
5382            {
5383                struct GeneratedVisitor;
5384
5385                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5386                    type Value = GeneratedField;
5387
5388                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5389                        write!(formatter, "expected one of: {:?}", &FIELDS)
5390                    }
5391
5392                    #[allow(unused_variables)]
5393                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5394                    where
5395                        E: serde::de::Error,
5396                    {
5397                        match value {
5398                            "source" => Ok(GeneratedField::Source),
5399                            "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5400                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5401                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5402                        }
5403                    }
5404                }
5405                deserializer.deserialize_identifier(GeneratedVisitor)
5406            }
5407        }
5408        struct GeneratedVisitor;
5409        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5410            type Value = CreateSourceRequest;
5411
5412            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5413                formatter.write_str("struct ddl_service.CreateSourceRequest")
5414            }
5415
5416            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
5417                where
5418                    V: serde::de::MapAccess<'de>,
5419            {
5420                let mut source__ = None;
5421                let mut fragment_graph__ = None;
5422                let mut if_not_exists__ = None;
5423                while let Some(k) = map_.next_key()? {
5424                    match k {
5425                        GeneratedField::Source => {
5426                            if source__.is_some() {
5427                                return Err(serde::de::Error::duplicate_field("source"));
5428                            }
5429                            source__ = map_.next_value()?;
5430                        }
5431                        GeneratedField::FragmentGraph => {
5432                            if fragment_graph__.is_some() {
5433                                return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5434                            }
5435                            fragment_graph__ = map_.next_value()?;
5436                        }
5437                        GeneratedField::IfNotExists => {
5438                            if if_not_exists__.is_some() {
5439                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
5440                            }
5441                            if_not_exists__ = Some(map_.next_value()?);
5442                        }
5443                    }
5444                }
5445                Ok(CreateSourceRequest {
5446                    source: source__,
5447                    fragment_graph: fragment_graph__,
5448                    if_not_exists: if_not_exists__.unwrap_or_default(),
5449                })
5450            }
5451        }
5452        deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
5453    }
5454}
5455impl serde::Serialize for CreateSourceResponse {
5456    #[allow(deprecated)]
5457    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5458    where
5459        S: serde::Serializer,
5460    {
5461        use serde::ser::SerializeStruct;
5462        let mut len = 0;
5463        if self.status.is_some() {
5464            len += 1;
5465        }
5466        if self.version.is_some() {
5467            len += 1;
5468        }
5469        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
5470        if let Some(v) = self.status.as_ref() {
5471            struct_ser.serialize_field("status", v)?;
5472        }
5473        if let Some(v) = self.version.as_ref() {
5474            struct_ser.serialize_field("version", v)?;
5475        }
5476        struct_ser.end()
5477    }
5478}
5479impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
5480    #[allow(deprecated)]
5481    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5482    where
5483        D: serde::Deserializer<'de>,
5484    {
5485        const FIELDS: &[&str] = &[
5486            "status",
5487            "version",
5488        ];
5489
5490        #[allow(clippy::enum_variant_names)]
5491        enum GeneratedField {
5492            Status,
5493            Version,
5494        }
5495        impl<'de> serde::Deserialize<'de> for GeneratedField {
5496            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5497            where
5498                D: serde::Deserializer<'de>,
5499            {
5500                struct GeneratedVisitor;
5501
5502                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5503                    type Value = GeneratedField;
5504
5505                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5506                        write!(formatter, "expected one of: {:?}", &FIELDS)
5507                    }
5508
5509                    #[allow(unused_variables)]
5510                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5511                    where
5512                        E: serde::de::Error,
5513                    {
5514                        match value {
5515                            "status" => Ok(GeneratedField::Status),
5516                            "version" => Ok(GeneratedField::Version),
5517                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5518                        }
5519                    }
5520                }
5521                deserializer.deserialize_identifier(GeneratedVisitor)
5522            }
5523        }
5524        struct GeneratedVisitor;
5525        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5526            type Value = CreateSourceResponse;
5527
5528            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5529                formatter.write_str("struct ddl_service.CreateSourceResponse")
5530            }
5531
5532            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
5533                where
5534                    V: serde::de::MapAccess<'de>,
5535            {
5536                let mut status__ = None;
5537                let mut version__ = None;
5538                while let Some(k) = map_.next_key()? {
5539                    match k {
5540                        GeneratedField::Status => {
5541                            if status__.is_some() {
5542                                return Err(serde::de::Error::duplicate_field("status"));
5543                            }
5544                            status__ = map_.next_value()?;
5545                        }
5546                        GeneratedField::Version => {
5547                            if version__.is_some() {
5548                                return Err(serde::de::Error::duplicate_field("version"));
5549                            }
5550                            version__ = map_.next_value()?;
5551                        }
5552                    }
5553                }
5554                Ok(CreateSourceResponse {
5555                    status: status__,
5556                    version: version__,
5557                })
5558            }
5559        }
5560        deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
5561    }
5562}
5563impl serde::Serialize for CreateSubscriptionRequest {
5564    #[allow(deprecated)]
5565    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5566    where
5567        S: serde::Serializer,
5568    {
5569        use serde::ser::SerializeStruct;
5570        let mut len = 0;
5571        if self.subscription.is_some() {
5572            len += 1;
5573        }
5574        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
5575        if let Some(v) = self.subscription.as_ref() {
5576            struct_ser.serialize_field("subscription", v)?;
5577        }
5578        struct_ser.end()
5579    }
5580}
5581impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
5582    #[allow(deprecated)]
5583    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5584    where
5585        D: serde::Deserializer<'de>,
5586    {
5587        const FIELDS: &[&str] = &[
5588            "subscription",
5589        ];
5590
5591        #[allow(clippy::enum_variant_names)]
5592        enum GeneratedField {
5593            Subscription,
5594        }
5595        impl<'de> serde::Deserialize<'de> for GeneratedField {
5596            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5597            where
5598                D: serde::Deserializer<'de>,
5599            {
5600                struct GeneratedVisitor;
5601
5602                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5603                    type Value = GeneratedField;
5604
5605                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5606                        write!(formatter, "expected one of: {:?}", &FIELDS)
5607                    }
5608
5609                    #[allow(unused_variables)]
5610                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5611                    where
5612                        E: serde::de::Error,
5613                    {
5614                        match value {
5615                            "subscription" => Ok(GeneratedField::Subscription),
5616                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5617                        }
5618                    }
5619                }
5620                deserializer.deserialize_identifier(GeneratedVisitor)
5621            }
5622        }
5623        struct GeneratedVisitor;
5624        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5625            type Value = CreateSubscriptionRequest;
5626
5627            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5628                formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
5629            }
5630
5631            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
5632                where
5633                    V: serde::de::MapAccess<'de>,
5634            {
5635                let mut subscription__ = None;
5636                while let Some(k) = map_.next_key()? {
5637                    match k {
5638                        GeneratedField::Subscription => {
5639                            if subscription__.is_some() {
5640                                return Err(serde::de::Error::duplicate_field("subscription"));
5641                            }
5642                            subscription__ = map_.next_value()?;
5643                        }
5644                    }
5645                }
5646                Ok(CreateSubscriptionRequest {
5647                    subscription: subscription__,
5648                })
5649            }
5650        }
5651        deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
5652    }
5653}
5654impl serde::Serialize for CreateSubscriptionResponse {
5655    #[allow(deprecated)]
5656    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5657    where
5658        S: serde::Serializer,
5659    {
5660        use serde::ser::SerializeStruct;
5661        let mut len = 0;
5662        if self.status.is_some() {
5663            len += 1;
5664        }
5665        if self.version.is_some() {
5666            len += 1;
5667        }
5668        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
5669        if let Some(v) = self.status.as_ref() {
5670            struct_ser.serialize_field("status", v)?;
5671        }
5672        if let Some(v) = self.version.as_ref() {
5673            struct_ser.serialize_field("version", v)?;
5674        }
5675        struct_ser.end()
5676    }
5677}
5678impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
5679    #[allow(deprecated)]
5680    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5681    where
5682        D: serde::Deserializer<'de>,
5683    {
5684        const FIELDS: &[&str] = &[
5685            "status",
5686            "version",
5687        ];
5688
5689        #[allow(clippy::enum_variant_names)]
5690        enum GeneratedField {
5691            Status,
5692            Version,
5693        }
5694        impl<'de> serde::Deserialize<'de> for GeneratedField {
5695            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5696            where
5697                D: serde::Deserializer<'de>,
5698            {
5699                struct GeneratedVisitor;
5700
5701                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5702                    type Value = GeneratedField;
5703
5704                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5705                        write!(formatter, "expected one of: {:?}", &FIELDS)
5706                    }
5707
5708                    #[allow(unused_variables)]
5709                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5710                    where
5711                        E: serde::de::Error,
5712                    {
5713                        match value {
5714                            "status" => Ok(GeneratedField::Status),
5715                            "version" => Ok(GeneratedField::Version),
5716                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5717                        }
5718                    }
5719                }
5720                deserializer.deserialize_identifier(GeneratedVisitor)
5721            }
5722        }
5723        struct GeneratedVisitor;
5724        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5725            type Value = CreateSubscriptionResponse;
5726
5727            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5728                formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
5729            }
5730
5731            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
5732                where
5733                    V: serde::de::MapAccess<'de>,
5734            {
5735                let mut status__ = None;
5736                let mut version__ = None;
5737                while let Some(k) = map_.next_key()? {
5738                    match k {
5739                        GeneratedField::Status => {
5740                            if status__.is_some() {
5741                                return Err(serde::de::Error::duplicate_field("status"));
5742                            }
5743                            status__ = map_.next_value()?;
5744                        }
5745                        GeneratedField::Version => {
5746                            if version__.is_some() {
5747                                return Err(serde::de::Error::duplicate_field("version"));
5748                            }
5749                            version__ = map_.next_value()?;
5750                        }
5751                    }
5752                }
5753                Ok(CreateSubscriptionResponse {
5754                    status: status__,
5755                    version: version__,
5756                })
5757            }
5758        }
5759        deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
5760    }
5761}
5762impl serde::Serialize for CreateTableRequest {
5763    #[allow(deprecated)]
5764    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5765    where
5766        S: serde::Serializer,
5767    {
5768        use serde::ser::SerializeStruct;
5769        let mut len = 0;
5770        if self.source.is_some() {
5771            len += 1;
5772        }
5773        if self.materialized_view.is_some() {
5774            len += 1;
5775        }
5776        if self.fragment_graph.is_some() {
5777            len += 1;
5778        }
5779        if self.job_type != 0 {
5780            len += 1;
5781        }
5782        if self.if_not_exists {
5783            len += 1;
5784        }
5785        if !self.dependencies.is_empty() {
5786            len += 1;
5787        }
5788        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
5789        if let Some(v) = self.source.as_ref() {
5790            struct_ser.serialize_field("source", v)?;
5791        }
5792        if let Some(v) = self.materialized_view.as_ref() {
5793            struct_ser.serialize_field("materializedView", v)?;
5794        }
5795        if let Some(v) = self.fragment_graph.as_ref() {
5796            struct_ser.serialize_field("fragmentGraph", v)?;
5797        }
5798        if self.job_type != 0 {
5799            let v = TableJobType::try_from(self.job_type)
5800                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
5801            struct_ser.serialize_field("jobType", &v)?;
5802        }
5803        if self.if_not_exists {
5804            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5805        }
5806        if !self.dependencies.is_empty() {
5807            struct_ser.serialize_field("dependencies", &self.dependencies)?;
5808        }
5809        struct_ser.end()
5810    }
5811}
5812impl<'de> serde::Deserialize<'de> for CreateTableRequest {
5813    #[allow(deprecated)]
5814    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5815    where
5816        D: serde::Deserializer<'de>,
5817    {
5818        const FIELDS: &[&str] = &[
5819            "source",
5820            "materialized_view",
5821            "materializedView",
5822            "fragment_graph",
5823            "fragmentGraph",
5824            "job_type",
5825            "jobType",
5826            "if_not_exists",
5827            "ifNotExists",
5828            "dependencies",
5829        ];
5830
5831        #[allow(clippy::enum_variant_names)]
5832        enum GeneratedField {
5833            Source,
5834            MaterializedView,
5835            FragmentGraph,
5836            JobType,
5837            IfNotExists,
5838            Dependencies,
5839        }
5840        impl<'de> serde::Deserialize<'de> for GeneratedField {
5841            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5842            where
5843                D: serde::Deserializer<'de>,
5844            {
5845                struct GeneratedVisitor;
5846
5847                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5848                    type Value = GeneratedField;
5849
5850                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5851                        write!(formatter, "expected one of: {:?}", &FIELDS)
5852                    }
5853
5854                    #[allow(unused_variables)]
5855                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5856                    where
5857                        E: serde::de::Error,
5858                    {
5859                        match value {
5860                            "source" => Ok(GeneratedField::Source),
5861                            "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5862                            "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5863                            "jobType" | "job_type" => Ok(GeneratedField::JobType),
5864                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5865                            "dependencies" => Ok(GeneratedField::Dependencies),
5866                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5867                        }
5868                    }
5869                }
5870                deserializer.deserialize_identifier(GeneratedVisitor)
5871            }
5872        }
5873        struct GeneratedVisitor;
5874        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5875            type Value = CreateTableRequest;
5876
5877            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5878                formatter.write_str("struct ddl_service.CreateTableRequest")
5879            }
5880
5881            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
5882                where
5883                    V: serde::de::MapAccess<'de>,
5884            {
5885                let mut source__ = None;
5886                let mut materialized_view__ = None;
5887                let mut fragment_graph__ = None;
5888                let mut job_type__ = None;
5889                let mut if_not_exists__ = None;
5890                let mut dependencies__ = None;
5891                while let Some(k) = map_.next_key()? {
5892                    match k {
5893                        GeneratedField::Source => {
5894                            if source__.is_some() {
5895                                return Err(serde::de::Error::duplicate_field("source"));
5896                            }
5897                            source__ = map_.next_value()?;
5898                        }
5899                        GeneratedField::MaterializedView => {
5900                            if materialized_view__.is_some() {
5901                                return Err(serde::de::Error::duplicate_field("materializedView"));
5902                            }
5903                            materialized_view__ = map_.next_value()?;
5904                        }
5905                        GeneratedField::FragmentGraph => {
5906                            if fragment_graph__.is_some() {
5907                                return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5908                            }
5909                            fragment_graph__ = map_.next_value()?;
5910                        }
5911                        GeneratedField::JobType => {
5912                            if job_type__.is_some() {
5913                                return Err(serde::de::Error::duplicate_field("jobType"));
5914                            }
5915                            job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
5916                        }
5917                        GeneratedField::IfNotExists => {
5918                            if if_not_exists__.is_some() {
5919                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
5920                            }
5921                            if_not_exists__ = Some(map_.next_value()?);
5922                        }
5923                        GeneratedField::Dependencies => {
5924                            if dependencies__.is_some() {
5925                                return Err(serde::de::Error::duplicate_field("dependencies"));
5926                            }
5927                            dependencies__ = 
5928                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5929                                    .into_iter().map(|x| x.0).collect())
5930                            ;
5931                        }
5932                    }
5933                }
5934                Ok(CreateTableRequest {
5935                    source: source__,
5936                    materialized_view: materialized_view__,
5937                    fragment_graph: fragment_graph__,
5938                    job_type: job_type__.unwrap_or_default(),
5939                    if_not_exists: if_not_exists__.unwrap_or_default(),
5940                    dependencies: dependencies__.unwrap_or_default(),
5941                })
5942            }
5943        }
5944        deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
5945    }
5946}
5947impl serde::Serialize for CreateTableResponse {
5948    #[allow(deprecated)]
5949    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5950    where
5951        S: serde::Serializer,
5952    {
5953        use serde::ser::SerializeStruct;
5954        let mut len = 0;
5955        if self.status.is_some() {
5956            len += 1;
5957        }
5958        if self.version.is_some() {
5959            len += 1;
5960        }
5961        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
5962        if let Some(v) = self.status.as_ref() {
5963            struct_ser.serialize_field("status", v)?;
5964        }
5965        if let Some(v) = self.version.as_ref() {
5966            struct_ser.serialize_field("version", v)?;
5967        }
5968        struct_ser.end()
5969    }
5970}
5971impl<'de> serde::Deserialize<'de> for CreateTableResponse {
5972    #[allow(deprecated)]
5973    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5974    where
5975        D: serde::Deserializer<'de>,
5976    {
5977        const FIELDS: &[&str] = &[
5978            "status",
5979            "version",
5980        ];
5981
5982        #[allow(clippy::enum_variant_names)]
5983        enum GeneratedField {
5984            Status,
5985            Version,
5986        }
5987        impl<'de> serde::Deserialize<'de> for GeneratedField {
5988            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5989            where
5990                D: serde::Deserializer<'de>,
5991            {
5992                struct GeneratedVisitor;
5993
5994                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5995                    type Value = GeneratedField;
5996
5997                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5998                        write!(formatter, "expected one of: {:?}", &FIELDS)
5999                    }
6000
6001                    #[allow(unused_variables)]
6002                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6003                    where
6004                        E: serde::de::Error,
6005                    {
6006                        match value {
6007                            "status" => Ok(GeneratedField::Status),
6008                            "version" => Ok(GeneratedField::Version),
6009                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6010                        }
6011                    }
6012                }
6013                deserializer.deserialize_identifier(GeneratedVisitor)
6014            }
6015        }
6016        struct GeneratedVisitor;
6017        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6018            type Value = CreateTableResponse;
6019
6020            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6021                formatter.write_str("struct ddl_service.CreateTableResponse")
6022            }
6023
6024            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
6025                where
6026                    V: serde::de::MapAccess<'de>,
6027            {
6028                let mut status__ = None;
6029                let mut version__ = None;
6030                while let Some(k) = map_.next_key()? {
6031                    match k {
6032                        GeneratedField::Status => {
6033                            if status__.is_some() {
6034                                return Err(serde::de::Error::duplicate_field("status"));
6035                            }
6036                            status__ = map_.next_value()?;
6037                        }
6038                        GeneratedField::Version => {
6039                            if version__.is_some() {
6040                                return Err(serde::de::Error::duplicate_field("version"));
6041                            }
6042                            version__ = map_.next_value()?;
6043                        }
6044                    }
6045                }
6046                Ok(CreateTableResponse {
6047                    status: status__,
6048                    version: version__,
6049                })
6050            }
6051        }
6052        deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
6053    }
6054}
6055impl serde::Serialize for CreateViewRequest {
6056    #[allow(deprecated)]
6057    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6058    where
6059        S: serde::Serializer,
6060    {
6061        use serde::ser::SerializeStruct;
6062        let mut len = 0;
6063        if self.view.is_some() {
6064            len += 1;
6065        }
6066        if !self.dependencies.is_empty() {
6067            len += 1;
6068        }
6069        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
6070        if let Some(v) = self.view.as_ref() {
6071            struct_ser.serialize_field("view", v)?;
6072        }
6073        if !self.dependencies.is_empty() {
6074            struct_ser.serialize_field("dependencies", &self.dependencies)?;
6075        }
6076        struct_ser.end()
6077    }
6078}
6079impl<'de> serde::Deserialize<'de> for CreateViewRequest {
6080    #[allow(deprecated)]
6081    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6082    where
6083        D: serde::Deserializer<'de>,
6084    {
6085        const FIELDS: &[&str] = &[
6086            "view",
6087            "dependencies",
6088        ];
6089
6090        #[allow(clippy::enum_variant_names)]
6091        enum GeneratedField {
6092            View,
6093            Dependencies,
6094        }
6095        impl<'de> serde::Deserialize<'de> for GeneratedField {
6096            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6097            where
6098                D: serde::Deserializer<'de>,
6099            {
6100                struct GeneratedVisitor;
6101
6102                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6103                    type Value = GeneratedField;
6104
6105                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6106                        write!(formatter, "expected one of: {:?}", &FIELDS)
6107                    }
6108
6109                    #[allow(unused_variables)]
6110                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6111                    where
6112                        E: serde::de::Error,
6113                    {
6114                        match value {
6115                            "view" => Ok(GeneratedField::View),
6116                            "dependencies" => Ok(GeneratedField::Dependencies),
6117                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6118                        }
6119                    }
6120                }
6121                deserializer.deserialize_identifier(GeneratedVisitor)
6122            }
6123        }
6124        struct GeneratedVisitor;
6125        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6126            type Value = CreateViewRequest;
6127
6128            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6129                formatter.write_str("struct ddl_service.CreateViewRequest")
6130            }
6131
6132            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
6133                where
6134                    V: serde::de::MapAccess<'de>,
6135            {
6136                let mut view__ = None;
6137                let mut dependencies__ = None;
6138                while let Some(k) = map_.next_key()? {
6139                    match k {
6140                        GeneratedField::View => {
6141                            if view__.is_some() {
6142                                return Err(serde::de::Error::duplicate_field("view"));
6143                            }
6144                            view__ = map_.next_value()?;
6145                        }
6146                        GeneratedField::Dependencies => {
6147                            if dependencies__.is_some() {
6148                                return Err(serde::de::Error::duplicate_field("dependencies"));
6149                            }
6150                            dependencies__ = 
6151                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6152                                    .into_iter().map(|x| x.0).collect())
6153                            ;
6154                        }
6155                    }
6156                }
6157                Ok(CreateViewRequest {
6158                    view: view__,
6159                    dependencies: dependencies__.unwrap_or_default(),
6160                })
6161            }
6162        }
6163        deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
6164    }
6165}
6166impl serde::Serialize for CreateViewResponse {
6167    #[allow(deprecated)]
6168    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6169    where
6170        S: serde::Serializer,
6171    {
6172        use serde::ser::SerializeStruct;
6173        let mut len = 0;
6174        if self.status.is_some() {
6175            len += 1;
6176        }
6177        if self.version.is_some() {
6178            len += 1;
6179        }
6180        let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
6181        if let Some(v) = self.status.as_ref() {
6182            struct_ser.serialize_field("status", v)?;
6183        }
6184        if let Some(v) = self.version.as_ref() {
6185            struct_ser.serialize_field("version", v)?;
6186        }
6187        struct_ser.end()
6188    }
6189}
6190impl<'de> serde::Deserialize<'de> for CreateViewResponse {
6191    #[allow(deprecated)]
6192    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6193    where
6194        D: serde::Deserializer<'de>,
6195    {
6196        const FIELDS: &[&str] = &[
6197            "status",
6198            "version",
6199        ];
6200
6201        #[allow(clippy::enum_variant_names)]
6202        enum GeneratedField {
6203            Status,
6204            Version,
6205        }
6206        impl<'de> serde::Deserialize<'de> for GeneratedField {
6207            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6208            where
6209                D: serde::Deserializer<'de>,
6210            {
6211                struct GeneratedVisitor;
6212
6213                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6214                    type Value = GeneratedField;
6215
6216                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6217                        write!(formatter, "expected one of: {:?}", &FIELDS)
6218                    }
6219
6220                    #[allow(unused_variables)]
6221                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6222                    where
6223                        E: serde::de::Error,
6224                    {
6225                        match value {
6226                            "status" => Ok(GeneratedField::Status),
6227                            "version" => Ok(GeneratedField::Version),
6228                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6229                        }
6230                    }
6231                }
6232                deserializer.deserialize_identifier(GeneratedVisitor)
6233            }
6234        }
6235        struct GeneratedVisitor;
6236        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6237            type Value = CreateViewResponse;
6238
6239            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6240                formatter.write_str("struct ddl_service.CreateViewResponse")
6241            }
6242
6243            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
6244                where
6245                    V: serde::de::MapAccess<'de>,
6246            {
6247                let mut status__ = None;
6248                let mut version__ = None;
6249                while let Some(k) = map_.next_key()? {
6250                    match k {
6251                        GeneratedField::Status => {
6252                            if status__.is_some() {
6253                                return Err(serde::de::Error::duplicate_field("status"));
6254                            }
6255                            status__ = map_.next_value()?;
6256                        }
6257                        GeneratedField::Version => {
6258                            if version__.is_some() {
6259                                return Err(serde::de::Error::duplicate_field("version"));
6260                            }
6261                            version__ = map_.next_value()?;
6262                        }
6263                    }
6264                }
6265                Ok(CreateViewResponse {
6266                    status: status__,
6267                    version: version__,
6268                })
6269            }
6270        }
6271        deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
6272    }
6273}
6274impl serde::Serialize for DdlProgress {
6275    #[allow(deprecated)]
6276    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6277    where
6278        S: serde::Serializer,
6279    {
6280        use serde::ser::SerializeStruct;
6281        let mut len = 0;
6282        if self.id != 0 {
6283            len += 1;
6284        }
6285        if !self.statement.is_empty() {
6286            len += 1;
6287        }
6288        if !self.progress.is_empty() {
6289            len += 1;
6290        }
6291        if !self.create_type.is_empty() {
6292            len += 1;
6293        }
6294        let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
6295        if self.id != 0 {
6296            #[allow(clippy::needless_borrow)]
6297            #[allow(clippy::needless_borrows_for_generic_args)]
6298            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6299        }
6300        if !self.statement.is_empty() {
6301            struct_ser.serialize_field("statement", &self.statement)?;
6302        }
6303        if !self.progress.is_empty() {
6304            struct_ser.serialize_field("progress", &self.progress)?;
6305        }
6306        if !self.create_type.is_empty() {
6307            struct_ser.serialize_field("createType", &self.create_type)?;
6308        }
6309        struct_ser.end()
6310    }
6311}
6312impl<'de> serde::Deserialize<'de> for DdlProgress {
6313    #[allow(deprecated)]
6314    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6315    where
6316        D: serde::Deserializer<'de>,
6317    {
6318        const FIELDS: &[&str] = &[
6319            "id",
6320            "statement",
6321            "progress",
6322            "create_type",
6323            "createType",
6324        ];
6325
6326        #[allow(clippy::enum_variant_names)]
6327        enum GeneratedField {
6328            Id,
6329            Statement,
6330            Progress,
6331            CreateType,
6332        }
6333        impl<'de> serde::Deserialize<'de> for GeneratedField {
6334            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6335            where
6336                D: serde::Deserializer<'de>,
6337            {
6338                struct GeneratedVisitor;
6339
6340                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6341                    type Value = GeneratedField;
6342
6343                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6344                        write!(formatter, "expected one of: {:?}", &FIELDS)
6345                    }
6346
6347                    #[allow(unused_variables)]
6348                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6349                    where
6350                        E: serde::de::Error,
6351                    {
6352                        match value {
6353                            "id" => Ok(GeneratedField::Id),
6354                            "statement" => Ok(GeneratedField::Statement),
6355                            "progress" => Ok(GeneratedField::Progress),
6356                            "createType" | "create_type" => Ok(GeneratedField::CreateType),
6357                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6358                        }
6359                    }
6360                }
6361                deserializer.deserialize_identifier(GeneratedVisitor)
6362            }
6363        }
6364        struct GeneratedVisitor;
6365        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6366            type Value = DdlProgress;
6367
6368            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6369                formatter.write_str("struct ddl_service.DdlProgress")
6370            }
6371
6372            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
6373                where
6374                    V: serde::de::MapAccess<'de>,
6375            {
6376                let mut id__ = None;
6377                let mut statement__ = None;
6378                let mut progress__ = None;
6379                let mut create_type__ = None;
6380                while let Some(k) = map_.next_key()? {
6381                    match k {
6382                        GeneratedField::Id => {
6383                            if id__.is_some() {
6384                                return Err(serde::de::Error::duplicate_field("id"));
6385                            }
6386                            id__ = 
6387                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6388                            ;
6389                        }
6390                        GeneratedField::Statement => {
6391                            if statement__.is_some() {
6392                                return Err(serde::de::Error::duplicate_field("statement"));
6393                            }
6394                            statement__ = Some(map_.next_value()?);
6395                        }
6396                        GeneratedField::Progress => {
6397                            if progress__.is_some() {
6398                                return Err(serde::de::Error::duplicate_field("progress"));
6399                            }
6400                            progress__ = Some(map_.next_value()?);
6401                        }
6402                        GeneratedField::CreateType => {
6403                            if create_type__.is_some() {
6404                                return Err(serde::de::Error::duplicate_field("createType"));
6405                            }
6406                            create_type__ = Some(map_.next_value()?);
6407                        }
6408                    }
6409                }
6410                Ok(DdlProgress {
6411                    id: id__.unwrap_or_default(),
6412                    statement: statement__.unwrap_or_default(),
6413                    progress: progress__.unwrap_or_default(),
6414                    create_type: create_type__.unwrap_or_default(),
6415                })
6416            }
6417        }
6418        deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
6419    }
6420}
6421impl serde::Serialize for DropConnectionRequest {
6422    #[allow(deprecated)]
6423    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6424    where
6425        S: serde::Serializer,
6426    {
6427        use serde::ser::SerializeStruct;
6428        let mut len = 0;
6429        if self.connection_id != 0 {
6430            len += 1;
6431        }
6432        if self.cascade {
6433            len += 1;
6434        }
6435        let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
6436        if self.connection_id != 0 {
6437            struct_ser.serialize_field("connectionId", &self.connection_id)?;
6438        }
6439        if self.cascade {
6440            struct_ser.serialize_field("cascade", &self.cascade)?;
6441        }
6442        struct_ser.end()
6443    }
6444}
6445impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
6446    #[allow(deprecated)]
6447    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6448    where
6449        D: serde::Deserializer<'de>,
6450    {
6451        const FIELDS: &[&str] = &[
6452            "connection_id",
6453            "connectionId",
6454            "cascade",
6455        ];
6456
6457        #[allow(clippy::enum_variant_names)]
6458        enum GeneratedField {
6459            ConnectionId,
6460            Cascade,
6461        }
6462        impl<'de> serde::Deserialize<'de> for GeneratedField {
6463            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6464            where
6465                D: serde::Deserializer<'de>,
6466            {
6467                struct GeneratedVisitor;
6468
6469                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6470                    type Value = GeneratedField;
6471
6472                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6473                        write!(formatter, "expected one of: {:?}", &FIELDS)
6474                    }
6475
6476                    #[allow(unused_variables)]
6477                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6478                    where
6479                        E: serde::de::Error,
6480                    {
6481                        match value {
6482                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
6483                            "cascade" => Ok(GeneratedField::Cascade),
6484                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6485                        }
6486                    }
6487                }
6488                deserializer.deserialize_identifier(GeneratedVisitor)
6489            }
6490        }
6491        struct GeneratedVisitor;
6492        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6493            type Value = DropConnectionRequest;
6494
6495            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6496                formatter.write_str("struct ddl_service.DropConnectionRequest")
6497            }
6498
6499            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
6500                where
6501                    V: serde::de::MapAccess<'de>,
6502            {
6503                let mut connection_id__ = None;
6504                let mut cascade__ = None;
6505                while let Some(k) = map_.next_key()? {
6506                    match k {
6507                        GeneratedField::ConnectionId => {
6508                            if connection_id__.is_some() {
6509                                return Err(serde::de::Error::duplicate_field("connectionId"));
6510                            }
6511                            connection_id__ = 
6512                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6513                            ;
6514                        }
6515                        GeneratedField::Cascade => {
6516                            if cascade__.is_some() {
6517                                return Err(serde::de::Error::duplicate_field("cascade"));
6518                            }
6519                            cascade__ = Some(map_.next_value()?);
6520                        }
6521                    }
6522                }
6523                Ok(DropConnectionRequest {
6524                    connection_id: connection_id__.unwrap_or_default(),
6525                    cascade: cascade__.unwrap_or_default(),
6526                })
6527            }
6528        }
6529        deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
6530    }
6531}
6532impl serde::Serialize for DropConnectionResponse {
6533    #[allow(deprecated)]
6534    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6535    where
6536        S: serde::Serializer,
6537    {
6538        use serde::ser::SerializeStruct;
6539        let mut len = 0;
6540        if self.status.is_some() {
6541            len += 1;
6542        }
6543        if self.version.is_some() {
6544            len += 1;
6545        }
6546        let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
6547        if let Some(v) = self.status.as_ref() {
6548            struct_ser.serialize_field("status", v)?;
6549        }
6550        if let Some(v) = self.version.as_ref() {
6551            struct_ser.serialize_field("version", v)?;
6552        }
6553        struct_ser.end()
6554    }
6555}
6556impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
6557    #[allow(deprecated)]
6558    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6559    where
6560        D: serde::Deserializer<'de>,
6561    {
6562        const FIELDS: &[&str] = &[
6563            "status",
6564            "version",
6565        ];
6566
6567        #[allow(clippy::enum_variant_names)]
6568        enum GeneratedField {
6569            Status,
6570            Version,
6571        }
6572        impl<'de> serde::Deserialize<'de> for GeneratedField {
6573            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6574            where
6575                D: serde::Deserializer<'de>,
6576            {
6577                struct GeneratedVisitor;
6578
6579                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6580                    type Value = GeneratedField;
6581
6582                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6583                        write!(formatter, "expected one of: {:?}", &FIELDS)
6584                    }
6585
6586                    #[allow(unused_variables)]
6587                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6588                    where
6589                        E: serde::de::Error,
6590                    {
6591                        match value {
6592                            "status" => Ok(GeneratedField::Status),
6593                            "version" => Ok(GeneratedField::Version),
6594                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6595                        }
6596                    }
6597                }
6598                deserializer.deserialize_identifier(GeneratedVisitor)
6599            }
6600        }
6601        struct GeneratedVisitor;
6602        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6603            type Value = DropConnectionResponse;
6604
6605            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6606                formatter.write_str("struct ddl_service.DropConnectionResponse")
6607            }
6608
6609            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
6610                where
6611                    V: serde::de::MapAccess<'de>,
6612            {
6613                let mut status__ = None;
6614                let mut version__ = None;
6615                while let Some(k) = map_.next_key()? {
6616                    match k {
6617                        GeneratedField::Status => {
6618                            if status__.is_some() {
6619                                return Err(serde::de::Error::duplicate_field("status"));
6620                            }
6621                            status__ = map_.next_value()?;
6622                        }
6623                        GeneratedField::Version => {
6624                            if version__.is_some() {
6625                                return Err(serde::de::Error::duplicate_field("version"));
6626                            }
6627                            version__ = map_.next_value()?;
6628                        }
6629                    }
6630                }
6631                Ok(DropConnectionResponse {
6632                    status: status__,
6633                    version: version__,
6634                })
6635            }
6636        }
6637        deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
6638    }
6639}
6640impl serde::Serialize for DropDatabaseRequest {
6641    #[allow(deprecated)]
6642    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6643    where
6644        S: serde::Serializer,
6645    {
6646        use serde::ser::SerializeStruct;
6647        let mut len = 0;
6648        if self.database_id != 0 {
6649            len += 1;
6650        }
6651        let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
6652        if self.database_id != 0 {
6653            struct_ser.serialize_field("databaseId", &self.database_id)?;
6654        }
6655        struct_ser.end()
6656    }
6657}
6658impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
6659    #[allow(deprecated)]
6660    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6661    where
6662        D: serde::Deserializer<'de>,
6663    {
6664        const FIELDS: &[&str] = &[
6665            "database_id",
6666            "databaseId",
6667        ];
6668
6669        #[allow(clippy::enum_variant_names)]
6670        enum GeneratedField {
6671            DatabaseId,
6672        }
6673        impl<'de> serde::Deserialize<'de> for GeneratedField {
6674            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6675            where
6676                D: serde::Deserializer<'de>,
6677            {
6678                struct GeneratedVisitor;
6679
6680                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6681                    type Value = GeneratedField;
6682
6683                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6684                        write!(formatter, "expected one of: {:?}", &FIELDS)
6685                    }
6686
6687                    #[allow(unused_variables)]
6688                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6689                    where
6690                        E: serde::de::Error,
6691                    {
6692                        match value {
6693                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6694                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6695                        }
6696                    }
6697                }
6698                deserializer.deserialize_identifier(GeneratedVisitor)
6699            }
6700        }
6701        struct GeneratedVisitor;
6702        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6703            type Value = DropDatabaseRequest;
6704
6705            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6706                formatter.write_str("struct ddl_service.DropDatabaseRequest")
6707            }
6708
6709            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
6710                where
6711                    V: serde::de::MapAccess<'de>,
6712            {
6713                let mut database_id__ = None;
6714                while let Some(k) = map_.next_key()? {
6715                    match k {
6716                        GeneratedField::DatabaseId => {
6717                            if database_id__.is_some() {
6718                                return Err(serde::de::Error::duplicate_field("databaseId"));
6719                            }
6720                            database_id__ = 
6721                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6722                            ;
6723                        }
6724                    }
6725                }
6726                Ok(DropDatabaseRequest {
6727                    database_id: database_id__.unwrap_or_default(),
6728                })
6729            }
6730        }
6731        deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
6732    }
6733}
6734impl serde::Serialize for DropDatabaseResponse {
6735    #[allow(deprecated)]
6736    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6737    where
6738        S: serde::Serializer,
6739    {
6740        use serde::ser::SerializeStruct;
6741        let mut len = 0;
6742        if self.status.is_some() {
6743            len += 1;
6744        }
6745        if self.version.is_some() {
6746            len += 1;
6747        }
6748        let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
6749        if let Some(v) = self.status.as_ref() {
6750            struct_ser.serialize_field("status", v)?;
6751        }
6752        if let Some(v) = self.version.as_ref() {
6753            struct_ser.serialize_field("version", v)?;
6754        }
6755        struct_ser.end()
6756    }
6757}
6758impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
6759    #[allow(deprecated)]
6760    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6761    where
6762        D: serde::Deserializer<'de>,
6763    {
6764        const FIELDS: &[&str] = &[
6765            "status",
6766            "version",
6767        ];
6768
6769        #[allow(clippy::enum_variant_names)]
6770        enum GeneratedField {
6771            Status,
6772            Version,
6773        }
6774        impl<'de> serde::Deserialize<'de> for GeneratedField {
6775            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6776            where
6777                D: serde::Deserializer<'de>,
6778            {
6779                struct GeneratedVisitor;
6780
6781                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6782                    type Value = GeneratedField;
6783
6784                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6785                        write!(formatter, "expected one of: {:?}", &FIELDS)
6786                    }
6787
6788                    #[allow(unused_variables)]
6789                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6790                    where
6791                        E: serde::de::Error,
6792                    {
6793                        match value {
6794                            "status" => Ok(GeneratedField::Status),
6795                            "version" => Ok(GeneratedField::Version),
6796                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6797                        }
6798                    }
6799                }
6800                deserializer.deserialize_identifier(GeneratedVisitor)
6801            }
6802        }
6803        struct GeneratedVisitor;
6804        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6805            type Value = DropDatabaseResponse;
6806
6807            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6808                formatter.write_str("struct ddl_service.DropDatabaseResponse")
6809            }
6810
6811            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
6812                where
6813                    V: serde::de::MapAccess<'de>,
6814            {
6815                let mut status__ = None;
6816                let mut version__ = None;
6817                while let Some(k) = map_.next_key()? {
6818                    match k {
6819                        GeneratedField::Status => {
6820                            if status__.is_some() {
6821                                return Err(serde::de::Error::duplicate_field("status"));
6822                            }
6823                            status__ = map_.next_value()?;
6824                        }
6825                        GeneratedField::Version => {
6826                            if version__.is_some() {
6827                                return Err(serde::de::Error::duplicate_field("version"));
6828                            }
6829                            version__ = map_.next_value()?;
6830                        }
6831                    }
6832                }
6833                Ok(DropDatabaseResponse {
6834                    status: status__,
6835                    version: version__,
6836                })
6837            }
6838        }
6839        deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
6840    }
6841}
6842impl serde::Serialize for DropFunctionRequest {
6843    #[allow(deprecated)]
6844    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6845    where
6846        S: serde::Serializer,
6847    {
6848        use serde::ser::SerializeStruct;
6849        let mut len = 0;
6850        if self.function_id != 0 {
6851            len += 1;
6852        }
6853        if self.cascade {
6854            len += 1;
6855        }
6856        let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
6857        if self.function_id != 0 {
6858            struct_ser.serialize_field("functionId", &self.function_id)?;
6859        }
6860        if self.cascade {
6861            struct_ser.serialize_field("cascade", &self.cascade)?;
6862        }
6863        struct_ser.end()
6864    }
6865}
6866impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
6867    #[allow(deprecated)]
6868    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6869    where
6870        D: serde::Deserializer<'de>,
6871    {
6872        const FIELDS: &[&str] = &[
6873            "function_id",
6874            "functionId",
6875            "cascade",
6876        ];
6877
6878        #[allow(clippy::enum_variant_names)]
6879        enum GeneratedField {
6880            FunctionId,
6881            Cascade,
6882        }
6883        impl<'de> serde::Deserialize<'de> for GeneratedField {
6884            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6885            where
6886                D: serde::Deserializer<'de>,
6887            {
6888                struct GeneratedVisitor;
6889
6890                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6891                    type Value = GeneratedField;
6892
6893                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6894                        write!(formatter, "expected one of: {:?}", &FIELDS)
6895                    }
6896
6897                    #[allow(unused_variables)]
6898                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6899                    where
6900                        E: serde::de::Error,
6901                    {
6902                        match value {
6903                            "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
6904                            "cascade" => Ok(GeneratedField::Cascade),
6905                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6906                        }
6907                    }
6908                }
6909                deserializer.deserialize_identifier(GeneratedVisitor)
6910            }
6911        }
6912        struct GeneratedVisitor;
6913        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6914            type Value = DropFunctionRequest;
6915
6916            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6917                formatter.write_str("struct ddl_service.DropFunctionRequest")
6918            }
6919
6920            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
6921                where
6922                    V: serde::de::MapAccess<'de>,
6923            {
6924                let mut function_id__ = None;
6925                let mut cascade__ = None;
6926                while let Some(k) = map_.next_key()? {
6927                    match k {
6928                        GeneratedField::FunctionId => {
6929                            if function_id__.is_some() {
6930                                return Err(serde::de::Error::duplicate_field("functionId"));
6931                            }
6932                            function_id__ = 
6933                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6934                            ;
6935                        }
6936                        GeneratedField::Cascade => {
6937                            if cascade__.is_some() {
6938                                return Err(serde::de::Error::duplicate_field("cascade"));
6939                            }
6940                            cascade__ = Some(map_.next_value()?);
6941                        }
6942                    }
6943                }
6944                Ok(DropFunctionRequest {
6945                    function_id: function_id__.unwrap_or_default(),
6946                    cascade: cascade__.unwrap_or_default(),
6947                })
6948            }
6949        }
6950        deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
6951    }
6952}
6953impl serde::Serialize for DropFunctionResponse {
6954    #[allow(deprecated)]
6955    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6956    where
6957        S: serde::Serializer,
6958    {
6959        use serde::ser::SerializeStruct;
6960        let mut len = 0;
6961        if self.status.is_some() {
6962            len += 1;
6963        }
6964        if self.version.is_some() {
6965            len += 1;
6966        }
6967        let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
6968        if let Some(v) = self.status.as_ref() {
6969            struct_ser.serialize_field("status", v)?;
6970        }
6971        if let Some(v) = self.version.as_ref() {
6972            struct_ser.serialize_field("version", v)?;
6973        }
6974        struct_ser.end()
6975    }
6976}
6977impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
6978    #[allow(deprecated)]
6979    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6980    where
6981        D: serde::Deserializer<'de>,
6982    {
6983        const FIELDS: &[&str] = &[
6984            "status",
6985            "version",
6986        ];
6987
6988        #[allow(clippy::enum_variant_names)]
6989        enum GeneratedField {
6990            Status,
6991            Version,
6992        }
6993        impl<'de> serde::Deserialize<'de> for GeneratedField {
6994            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6995            where
6996                D: serde::Deserializer<'de>,
6997            {
6998                struct GeneratedVisitor;
6999
7000                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7001                    type Value = GeneratedField;
7002
7003                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7004                        write!(formatter, "expected one of: {:?}", &FIELDS)
7005                    }
7006
7007                    #[allow(unused_variables)]
7008                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7009                    where
7010                        E: serde::de::Error,
7011                    {
7012                        match value {
7013                            "status" => Ok(GeneratedField::Status),
7014                            "version" => Ok(GeneratedField::Version),
7015                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7016                        }
7017                    }
7018                }
7019                deserializer.deserialize_identifier(GeneratedVisitor)
7020            }
7021        }
7022        struct GeneratedVisitor;
7023        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7024            type Value = DropFunctionResponse;
7025
7026            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7027                formatter.write_str("struct ddl_service.DropFunctionResponse")
7028            }
7029
7030            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
7031                where
7032                    V: serde::de::MapAccess<'de>,
7033            {
7034                let mut status__ = None;
7035                let mut version__ = None;
7036                while let Some(k) = map_.next_key()? {
7037                    match k {
7038                        GeneratedField::Status => {
7039                            if status__.is_some() {
7040                                return Err(serde::de::Error::duplicate_field("status"));
7041                            }
7042                            status__ = map_.next_value()?;
7043                        }
7044                        GeneratedField::Version => {
7045                            if version__.is_some() {
7046                                return Err(serde::de::Error::duplicate_field("version"));
7047                            }
7048                            version__ = map_.next_value()?;
7049                        }
7050                    }
7051                }
7052                Ok(DropFunctionResponse {
7053                    status: status__,
7054                    version: version__,
7055                })
7056            }
7057        }
7058        deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
7059    }
7060}
7061impl serde::Serialize for DropIndexRequest {
7062    #[allow(deprecated)]
7063    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7064    where
7065        S: serde::Serializer,
7066    {
7067        use serde::ser::SerializeStruct;
7068        let mut len = 0;
7069        if self.index_id != 0 {
7070            len += 1;
7071        }
7072        if self.cascade {
7073            len += 1;
7074        }
7075        let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
7076        if self.index_id != 0 {
7077            struct_ser.serialize_field("indexId", &self.index_id)?;
7078        }
7079        if self.cascade {
7080            struct_ser.serialize_field("cascade", &self.cascade)?;
7081        }
7082        struct_ser.end()
7083    }
7084}
7085impl<'de> serde::Deserialize<'de> for DropIndexRequest {
7086    #[allow(deprecated)]
7087    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7088    where
7089        D: serde::Deserializer<'de>,
7090    {
7091        const FIELDS: &[&str] = &[
7092            "index_id",
7093            "indexId",
7094            "cascade",
7095        ];
7096
7097        #[allow(clippy::enum_variant_names)]
7098        enum GeneratedField {
7099            IndexId,
7100            Cascade,
7101        }
7102        impl<'de> serde::Deserialize<'de> for GeneratedField {
7103            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7104            where
7105                D: serde::Deserializer<'de>,
7106            {
7107                struct GeneratedVisitor;
7108
7109                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7110                    type Value = GeneratedField;
7111
7112                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7113                        write!(formatter, "expected one of: {:?}", &FIELDS)
7114                    }
7115
7116                    #[allow(unused_variables)]
7117                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7118                    where
7119                        E: serde::de::Error,
7120                    {
7121                        match value {
7122                            "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7123                            "cascade" => Ok(GeneratedField::Cascade),
7124                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7125                        }
7126                    }
7127                }
7128                deserializer.deserialize_identifier(GeneratedVisitor)
7129            }
7130        }
7131        struct GeneratedVisitor;
7132        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7133            type Value = DropIndexRequest;
7134
7135            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7136                formatter.write_str("struct ddl_service.DropIndexRequest")
7137            }
7138
7139            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
7140                where
7141                    V: serde::de::MapAccess<'de>,
7142            {
7143                let mut index_id__ = None;
7144                let mut cascade__ = None;
7145                while let Some(k) = map_.next_key()? {
7146                    match k {
7147                        GeneratedField::IndexId => {
7148                            if index_id__.is_some() {
7149                                return Err(serde::de::Error::duplicate_field("indexId"));
7150                            }
7151                            index_id__ = 
7152                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7153                            ;
7154                        }
7155                        GeneratedField::Cascade => {
7156                            if cascade__.is_some() {
7157                                return Err(serde::de::Error::duplicate_field("cascade"));
7158                            }
7159                            cascade__ = Some(map_.next_value()?);
7160                        }
7161                    }
7162                }
7163                Ok(DropIndexRequest {
7164                    index_id: index_id__.unwrap_or_default(),
7165                    cascade: cascade__.unwrap_or_default(),
7166                })
7167            }
7168        }
7169        deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
7170    }
7171}
7172impl serde::Serialize for DropIndexResponse {
7173    #[allow(deprecated)]
7174    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7175    where
7176        S: serde::Serializer,
7177    {
7178        use serde::ser::SerializeStruct;
7179        let mut len = 0;
7180        if self.status.is_some() {
7181            len += 1;
7182        }
7183        if self.version.is_some() {
7184            len += 1;
7185        }
7186        let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
7187        if let Some(v) = self.status.as_ref() {
7188            struct_ser.serialize_field("status", v)?;
7189        }
7190        if let Some(v) = self.version.as_ref() {
7191            struct_ser.serialize_field("version", v)?;
7192        }
7193        struct_ser.end()
7194    }
7195}
7196impl<'de> serde::Deserialize<'de> for DropIndexResponse {
7197    #[allow(deprecated)]
7198    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7199    where
7200        D: serde::Deserializer<'de>,
7201    {
7202        const FIELDS: &[&str] = &[
7203            "status",
7204            "version",
7205        ];
7206
7207        #[allow(clippy::enum_variant_names)]
7208        enum GeneratedField {
7209            Status,
7210            Version,
7211        }
7212        impl<'de> serde::Deserialize<'de> for GeneratedField {
7213            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7214            where
7215                D: serde::Deserializer<'de>,
7216            {
7217                struct GeneratedVisitor;
7218
7219                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7220                    type Value = GeneratedField;
7221
7222                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7223                        write!(formatter, "expected one of: {:?}", &FIELDS)
7224                    }
7225
7226                    #[allow(unused_variables)]
7227                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7228                    where
7229                        E: serde::de::Error,
7230                    {
7231                        match value {
7232                            "status" => Ok(GeneratedField::Status),
7233                            "version" => Ok(GeneratedField::Version),
7234                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7235                        }
7236                    }
7237                }
7238                deserializer.deserialize_identifier(GeneratedVisitor)
7239            }
7240        }
7241        struct GeneratedVisitor;
7242        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7243            type Value = DropIndexResponse;
7244
7245            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7246                formatter.write_str("struct ddl_service.DropIndexResponse")
7247            }
7248
7249            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
7250                where
7251                    V: serde::de::MapAccess<'de>,
7252            {
7253                let mut status__ = None;
7254                let mut version__ = None;
7255                while let Some(k) = map_.next_key()? {
7256                    match k {
7257                        GeneratedField::Status => {
7258                            if status__.is_some() {
7259                                return Err(serde::de::Error::duplicate_field("status"));
7260                            }
7261                            status__ = map_.next_value()?;
7262                        }
7263                        GeneratedField::Version => {
7264                            if version__.is_some() {
7265                                return Err(serde::de::Error::duplicate_field("version"));
7266                            }
7267                            version__ = map_.next_value()?;
7268                        }
7269                    }
7270                }
7271                Ok(DropIndexResponse {
7272                    status: status__,
7273                    version: version__,
7274                })
7275            }
7276        }
7277        deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
7278    }
7279}
7280impl serde::Serialize for DropMaterializedViewRequest {
7281    #[allow(deprecated)]
7282    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7283    where
7284        S: serde::Serializer,
7285    {
7286        use serde::ser::SerializeStruct;
7287        let mut len = 0;
7288        if self.table_id != 0 {
7289            len += 1;
7290        }
7291        if self.cascade {
7292            len += 1;
7293        }
7294        let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
7295        if self.table_id != 0 {
7296            struct_ser.serialize_field("tableId", &self.table_id)?;
7297        }
7298        if self.cascade {
7299            struct_ser.serialize_field("cascade", &self.cascade)?;
7300        }
7301        struct_ser.end()
7302    }
7303}
7304impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
7305    #[allow(deprecated)]
7306    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7307    where
7308        D: serde::Deserializer<'de>,
7309    {
7310        const FIELDS: &[&str] = &[
7311            "table_id",
7312            "tableId",
7313            "cascade",
7314        ];
7315
7316        #[allow(clippy::enum_variant_names)]
7317        enum GeneratedField {
7318            TableId,
7319            Cascade,
7320        }
7321        impl<'de> serde::Deserialize<'de> for GeneratedField {
7322            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7323            where
7324                D: serde::Deserializer<'de>,
7325            {
7326                struct GeneratedVisitor;
7327
7328                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7329                    type Value = GeneratedField;
7330
7331                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7332                        write!(formatter, "expected one of: {:?}", &FIELDS)
7333                    }
7334
7335                    #[allow(unused_variables)]
7336                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7337                    where
7338                        E: serde::de::Error,
7339                    {
7340                        match value {
7341                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
7342                            "cascade" => Ok(GeneratedField::Cascade),
7343                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7344                        }
7345                    }
7346                }
7347                deserializer.deserialize_identifier(GeneratedVisitor)
7348            }
7349        }
7350        struct GeneratedVisitor;
7351        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7352            type Value = DropMaterializedViewRequest;
7353
7354            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7355                formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
7356            }
7357
7358            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
7359                where
7360                    V: serde::de::MapAccess<'de>,
7361            {
7362                let mut table_id__ = None;
7363                let mut cascade__ = None;
7364                while let Some(k) = map_.next_key()? {
7365                    match k {
7366                        GeneratedField::TableId => {
7367                            if table_id__.is_some() {
7368                                return Err(serde::de::Error::duplicate_field("tableId"));
7369                            }
7370                            table_id__ = 
7371                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7372                            ;
7373                        }
7374                        GeneratedField::Cascade => {
7375                            if cascade__.is_some() {
7376                                return Err(serde::de::Error::duplicate_field("cascade"));
7377                            }
7378                            cascade__ = Some(map_.next_value()?);
7379                        }
7380                    }
7381                }
7382                Ok(DropMaterializedViewRequest {
7383                    table_id: table_id__.unwrap_or_default(),
7384                    cascade: cascade__.unwrap_or_default(),
7385                })
7386            }
7387        }
7388        deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
7389    }
7390}
7391impl serde::Serialize for DropMaterializedViewResponse {
7392    #[allow(deprecated)]
7393    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7394    where
7395        S: serde::Serializer,
7396    {
7397        use serde::ser::SerializeStruct;
7398        let mut len = 0;
7399        if self.status.is_some() {
7400            len += 1;
7401        }
7402        if self.version.is_some() {
7403            len += 1;
7404        }
7405        let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
7406        if let Some(v) = self.status.as_ref() {
7407            struct_ser.serialize_field("status", v)?;
7408        }
7409        if let Some(v) = self.version.as_ref() {
7410            struct_ser.serialize_field("version", v)?;
7411        }
7412        struct_ser.end()
7413    }
7414}
7415impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
7416    #[allow(deprecated)]
7417    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7418    where
7419        D: serde::Deserializer<'de>,
7420    {
7421        const FIELDS: &[&str] = &[
7422            "status",
7423            "version",
7424        ];
7425
7426        #[allow(clippy::enum_variant_names)]
7427        enum GeneratedField {
7428            Status,
7429            Version,
7430        }
7431        impl<'de> serde::Deserialize<'de> for GeneratedField {
7432            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7433            where
7434                D: serde::Deserializer<'de>,
7435            {
7436                struct GeneratedVisitor;
7437
7438                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7439                    type Value = GeneratedField;
7440
7441                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7442                        write!(formatter, "expected one of: {:?}", &FIELDS)
7443                    }
7444
7445                    #[allow(unused_variables)]
7446                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7447                    where
7448                        E: serde::de::Error,
7449                    {
7450                        match value {
7451                            "status" => Ok(GeneratedField::Status),
7452                            "version" => Ok(GeneratedField::Version),
7453                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7454                        }
7455                    }
7456                }
7457                deserializer.deserialize_identifier(GeneratedVisitor)
7458            }
7459        }
7460        struct GeneratedVisitor;
7461        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7462            type Value = DropMaterializedViewResponse;
7463
7464            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7465                formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
7466            }
7467
7468            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
7469                where
7470                    V: serde::de::MapAccess<'de>,
7471            {
7472                let mut status__ = None;
7473                let mut version__ = None;
7474                while let Some(k) = map_.next_key()? {
7475                    match k {
7476                        GeneratedField::Status => {
7477                            if status__.is_some() {
7478                                return Err(serde::de::Error::duplicate_field("status"));
7479                            }
7480                            status__ = map_.next_value()?;
7481                        }
7482                        GeneratedField::Version => {
7483                            if version__.is_some() {
7484                                return Err(serde::de::Error::duplicate_field("version"));
7485                            }
7486                            version__ = map_.next_value()?;
7487                        }
7488                    }
7489                }
7490                Ok(DropMaterializedViewResponse {
7491                    status: status__,
7492                    version: version__,
7493                })
7494            }
7495        }
7496        deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
7497    }
7498}
7499impl serde::Serialize for DropSchemaRequest {
7500    #[allow(deprecated)]
7501    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7502    where
7503        S: serde::Serializer,
7504    {
7505        use serde::ser::SerializeStruct;
7506        let mut len = 0;
7507        if self.schema_id != 0 {
7508            len += 1;
7509        }
7510        if self.cascade {
7511            len += 1;
7512        }
7513        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
7514        if self.schema_id != 0 {
7515            struct_ser.serialize_field("schemaId", &self.schema_id)?;
7516        }
7517        if self.cascade {
7518            struct_ser.serialize_field("cascade", &self.cascade)?;
7519        }
7520        struct_ser.end()
7521    }
7522}
7523impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
7524    #[allow(deprecated)]
7525    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7526    where
7527        D: serde::Deserializer<'de>,
7528    {
7529        const FIELDS: &[&str] = &[
7530            "schema_id",
7531            "schemaId",
7532            "cascade",
7533        ];
7534
7535        #[allow(clippy::enum_variant_names)]
7536        enum GeneratedField {
7537            SchemaId,
7538            Cascade,
7539        }
7540        impl<'de> serde::Deserialize<'de> for GeneratedField {
7541            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7542            where
7543                D: serde::Deserializer<'de>,
7544            {
7545                struct GeneratedVisitor;
7546
7547                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7548                    type Value = GeneratedField;
7549
7550                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7551                        write!(formatter, "expected one of: {:?}", &FIELDS)
7552                    }
7553
7554                    #[allow(unused_variables)]
7555                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7556                    where
7557                        E: serde::de::Error,
7558                    {
7559                        match value {
7560                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
7561                            "cascade" => Ok(GeneratedField::Cascade),
7562                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7563                        }
7564                    }
7565                }
7566                deserializer.deserialize_identifier(GeneratedVisitor)
7567            }
7568        }
7569        struct GeneratedVisitor;
7570        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7571            type Value = DropSchemaRequest;
7572
7573            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7574                formatter.write_str("struct ddl_service.DropSchemaRequest")
7575            }
7576
7577            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
7578                where
7579                    V: serde::de::MapAccess<'de>,
7580            {
7581                let mut schema_id__ = None;
7582                let mut cascade__ = None;
7583                while let Some(k) = map_.next_key()? {
7584                    match k {
7585                        GeneratedField::SchemaId => {
7586                            if schema_id__.is_some() {
7587                                return Err(serde::de::Error::duplicate_field("schemaId"));
7588                            }
7589                            schema_id__ = 
7590                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7591                            ;
7592                        }
7593                        GeneratedField::Cascade => {
7594                            if cascade__.is_some() {
7595                                return Err(serde::de::Error::duplicate_field("cascade"));
7596                            }
7597                            cascade__ = Some(map_.next_value()?);
7598                        }
7599                    }
7600                }
7601                Ok(DropSchemaRequest {
7602                    schema_id: schema_id__.unwrap_or_default(),
7603                    cascade: cascade__.unwrap_or_default(),
7604                })
7605            }
7606        }
7607        deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
7608    }
7609}
7610impl serde::Serialize for DropSchemaResponse {
7611    #[allow(deprecated)]
7612    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7613    where
7614        S: serde::Serializer,
7615    {
7616        use serde::ser::SerializeStruct;
7617        let mut len = 0;
7618        if self.status.is_some() {
7619            len += 1;
7620        }
7621        if self.version.is_some() {
7622            len += 1;
7623        }
7624        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
7625        if let Some(v) = self.status.as_ref() {
7626            struct_ser.serialize_field("status", v)?;
7627        }
7628        if let Some(v) = self.version.as_ref() {
7629            struct_ser.serialize_field("version", v)?;
7630        }
7631        struct_ser.end()
7632    }
7633}
7634impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
7635    #[allow(deprecated)]
7636    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7637    where
7638        D: serde::Deserializer<'de>,
7639    {
7640        const FIELDS: &[&str] = &[
7641            "status",
7642            "version",
7643        ];
7644
7645        #[allow(clippy::enum_variant_names)]
7646        enum GeneratedField {
7647            Status,
7648            Version,
7649        }
7650        impl<'de> serde::Deserialize<'de> for GeneratedField {
7651            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7652            where
7653                D: serde::Deserializer<'de>,
7654            {
7655                struct GeneratedVisitor;
7656
7657                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7658                    type Value = GeneratedField;
7659
7660                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7661                        write!(formatter, "expected one of: {:?}", &FIELDS)
7662                    }
7663
7664                    #[allow(unused_variables)]
7665                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7666                    where
7667                        E: serde::de::Error,
7668                    {
7669                        match value {
7670                            "status" => Ok(GeneratedField::Status),
7671                            "version" => Ok(GeneratedField::Version),
7672                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7673                        }
7674                    }
7675                }
7676                deserializer.deserialize_identifier(GeneratedVisitor)
7677            }
7678        }
7679        struct GeneratedVisitor;
7680        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7681            type Value = DropSchemaResponse;
7682
7683            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7684                formatter.write_str("struct ddl_service.DropSchemaResponse")
7685            }
7686
7687            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
7688                where
7689                    V: serde::de::MapAccess<'de>,
7690            {
7691                let mut status__ = None;
7692                let mut version__ = None;
7693                while let Some(k) = map_.next_key()? {
7694                    match k {
7695                        GeneratedField::Status => {
7696                            if status__.is_some() {
7697                                return Err(serde::de::Error::duplicate_field("status"));
7698                            }
7699                            status__ = map_.next_value()?;
7700                        }
7701                        GeneratedField::Version => {
7702                            if version__.is_some() {
7703                                return Err(serde::de::Error::duplicate_field("version"));
7704                            }
7705                            version__ = map_.next_value()?;
7706                        }
7707                    }
7708                }
7709                Ok(DropSchemaResponse {
7710                    status: status__,
7711                    version: version__,
7712                })
7713            }
7714        }
7715        deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
7716    }
7717}
7718impl serde::Serialize for DropSecretRequest {
7719    #[allow(deprecated)]
7720    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7721    where
7722        S: serde::Serializer,
7723    {
7724        use serde::ser::SerializeStruct;
7725        let mut len = 0;
7726        if self.secret_id != 0 {
7727            len += 1;
7728        }
7729        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
7730        if self.secret_id != 0 {
7731            struct_ser.serialize_field("secretId", &self.secret_id)?;
7732        }
7733        struct_ser.end()
7734    }
7735}
7736impl<'de> serde::Deserialize<'de> for DropSecretRequest {
7737    #[allow(deprecated)]
7738    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7739    where
7740        D: serde::Deserializer<'de>,
7741    {
7742        const FIELDS: &[&str] = &[
7743            "secret_id",
7744            "secretId",
7745        ];
7746
7747        #[allow(clippy::enum_variant_names)]
7748        enum GeneratedField {
7749            SecretId,
7750        }
7751        impl<'de> serde::Deserialize<'de> for GeneratedField {
7752            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7753            where
7754                D: serde::Deserializer<'de>,
7755            {
7756                struct GeneratedVisitor;
7757
7758                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7759                    type Value = GeneratedField;
7760
7761                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7762                        write!(formatter, "expected one of: {:?}", &FIELDS)
7763                    }
7764
7765                    #[allow(unused_variables)]
7766                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7767                    where
7768                        E: serde::de::Error,
7769                    {
7770                        match value {
7771                            "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
7772                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7773                        }
7774                    }
7775                }
7776                deserializer.deserialize_identifier(GeneratedVisitor)
7777            }
7778        }
7779        struct GeneratedVisitor;
7780        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7781            type Value = DropSecretRequest;
7782
7783            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7784                formatter.write_str("struct ddl_service.DropSecretRequest")
7785            }
7786
7787            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
7788                where
7789                    V: serde::de::MapAccess<'de>,
7790            {
7791                let mut secret_id__ = None;
7792                while let Some(k) = map_.next_key()? {
7793                    match k {
7794                        GeneratedField::SecretId => {
7795                            if secret_id__.is_some() {
7796                                return Err(serde::de::Error::duplicate_field("secretId"));
7797                            }
7798                            secret_id__ = 
7799                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7800                            ;
7801                        }
7802                    }
7803                }
7804                Ok(DropSecretRequest {
7805                    secret_id: secret_id__.unwrap_or_default(),
7806                })
7807            }
7808        }
7809        deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
7810    }
7811}
7812impl serde::Serialize for DropSecretResponse {
7813    #[allow(deprecated)]
7814    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7815    where
7816        S: serde::Serializer,
7817    {
7818        use serde::ser::SerializeStruct;
7819        let mut len = 0;
7820        if self.version.is_some() {
7821            len += 1;
7822        }
7823        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
7824        if let Some(v) = self.version.as_ref() {
7825            struct_ser.serialize_field("version", v)?;
7826        }
7827        struct_ser.end()
7828    }
7829}
7830impl<'de> serde::Deserialize<'de> for DropSecretResponse {
7831    #[allow(deprecated)]
7832    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7833    where
7834        D: serde::Deserializer<'de>,
7835    {
7836        const FIELDS: &[&str] = &[
7837            "version",
7838        ];
7839
7840        #[allow(clippy::enum_variant_names)]
7841        enum GeneratedField {
7842            Version,
7843        }
7844        impl<'de> serde::Deserialize<'de> for GeneratedField {
7845            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7846            where
7847                D: serde::Deserializer<'de>,
7848            {
7849                struct GeneratedVisitor;
7850
7851                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7852                    type Value = GeneratedField;
7853
7854                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7855                        write!(formatter, "expected one of: {:?}", &FIELDS)
7856                    }
7857
7858                    #[allow(unused_variables)]
7859                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7860                    where
7861                        E: serde::de::Error,
7862                    {
7863                        match value {
7864                            "version" => Ok(GeneratedField::Version),
7865                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7866                        }
7867                    }
7868                }
7869                deserializer.deserialize_identifier(GeneratedVisitor)
7870            }
7871        }
7872        struct GeneratedVisitor;
7873        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7874            type Value = DropSecretResponse;
7875
7876            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7877                formatter.write_str("struct ddl_service.DropSecretResponse")
7878            }
7879
7880            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
7881                where
7882                    V: serde::de::MapAccess<'de>,
7883            {
7884                let mut version__ = None;
7885                while let Some(k) = map_.next_key()? {
7886                    match k {
7887                        GeneratedField::Version => {
7888                            if version__.is_some() {
7889                                return Err(serde::de::Error::duplicate_field("version"));
7890                            }
7891                            version__ = map_.next_value()?;
7892                        }
7893                    }
7894                }
7895                Ok(DropSecretResponse {
7896                    version: version__,
7897                })
7898            }
7899        }
7900        deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
7901    }
7902}
7903impl serde::Serialize for DropSinkRequest {
7904    #[allow(deprecated)]
7905    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7906    where
7907        S: serde::Serializer,
7908    {
7909        use serde::ser::SerializeStruct;
7910        let mut len = 0;
7911        if self.sink_id != 0 {
7912            len += 1;
7913        }
7914        if self.cascade {
7915            len += 1;
7916        }
7917        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
7918        if self.sink_id != 0 {
7919            struct_ser.serialize_field("sinkId", &self.sink_id)?;
7920        }
7921        if self.cascade {
7922            struct_ser.serialize_field("cascade", &self.cascade)?;
7923        }
7924        struct_ser.end()
7925    }
7926}
7927impl<'de> serde::Deserialize<'de> for DropSinkRequest {
7928    #[allow(deprecated)]
7929    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7930    where
7931        D: serde::Deserializer<'de>,
7932    {
7933        const FIELDS: &[&str] = &[
7934            "sink_id",
7935            "sinkId",
7936            "cascade",
7937        ];
7938
7939        #[allow(clippy::enum_variant_names)]
7940        enum GeneratedField {
7941            SinkId,
7942            Cascade,
7943        }
7944        impl<'de> serde::Deserialize<'de> for GeneratedField {
7945            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7946            where
7947                D: serde::Deserializer<'de>,
7948            {
7949                struct GeneratedVisitor;
7950
7951                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7952                    type Value = GeneratedField;
7953
7954                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7955                        write!(formatter, "expected one of: {:?}", &FIELDS)
7956                    }
7957
7958                    #[allow(unused_variables)]
7959                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7960                    where
7961                        E: serde::de::Error,
7962                    {
7963                        match value {
7964                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
7965                            "cascade" => Ok(GeneratedField::Cascade),
7966                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7967                        }
7968                    }
7969                }
7970                deserializer.deserialize_identifier(GeneratedVisitor)
7971            }
7972        }
7973        struct GeneratedVisitor;
7974        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7975            type Value = DropSinkRequest;
7976
7977            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7978                formatter.write_str("struct ddl_service.DropSinkRequest")
7979            }
7980
7981            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
7982                where
7983                    V: serde::de::MapAccess<'de>,
7984            {
7985                let mut sink_id__ = None;
7986                let mut cascade__ = None;
7987                while let Some(k) = map_.next_key()? {
7988                    match k {
7989                        GeneratedField::SinkId => {
7990                            if sink_id__.is_some() {
7991                                return Err(serde::de::Error::duplicate_field("sinkId"));
7992                            }
7993                            sink_id__ = 
7994                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7995                            ;
7996                        }
7997                        GeneratedField::Cascade => {
7998                            if cascade__.is_some() {
7999                                return Err(serde::de::Error::duplicate_field("cascade"));
8000                            }
8001                            cascade__ = Some(map_.next_value()?);
8002                        }
8003                    }
8004                }
8005                Ok(DropSinkRequest {
8006                    sink_id: sink_id__.unwrap_or_default(),
8007                    cascade: cascade__.unwrap_or_default(),
8008                })
8009            }
8010        }
8011        deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
8012    }
8013}
8014impl serde::Serialize for DropSinkResponse {
8015    #[allow(deprecated)]
8016    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8017    where
8018        S: serde::Serializer,
8019    {
8020        use serde::ser::SerializeStruct;
8021        let mut len = 0;
8022        if self.status.is_some() {
8023            len += 1;
8024        }
8025        if self.version.is_some() {
8026            len += 1;
8027        }
8028        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
8029        if let Some(v) = self.status.as_ref() {
8030            struct_ser.serialize_field("status", v)?;
8031        }
8032        if let Some(v) = self.version.as_ref() {
8033            struct_ser.serialize_field("version", v)?;
8034        }
8035        struct_ser.end()
8036    }
8037}
8038impl<'de> serde::Deserialize<'de> for DropSinkResponse {
8039    #[allow(deprecated)]
8040    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8041    where
8042        D: serde::Deserializer<'de>,
8043    {
8044        const FIELDS: &[&str] = &[
8045            "status",
8046            "version",
8047        ];
8048
8049        #[allow(clippy::enum_variant_names)]
8050        enum GeneratedField {
8051            Status,
8052            Version,
8053        }
8054        impl<'de> serde::Deserialize<'de> for GeneratedField {
8055            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8056            where
8057                D: serde::Deserializer<'de>,
8058            {
8059                struct GeneratedVisitor;
8060
8061                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8062                    type Value = GeneratedField;
8063
8064                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8065                        write!(formatter, "expected one of: {:?}", &FIELDS)
8066                    }
8067
8068                    #[allow(unused_variables)]
8069                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8070                    where
8071                        E: serde::de::Error,
8072                    {
8073                        match value {
8074                            "status" => Ok(GeneratedField::Status),
8075                            "version" => Ok(GeneratedField::Version),
8076                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8077                        }
8078                    }
8079                }
8080                deserializer.deserialize_identifier(GeneratedVisitor)
8081            }
8082        }
8083        struct GeneratedVisitor;
8084        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8085            type Value = DropSinkResponse;
8086
8087            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8088                formatter.write_str("struct ddl_service.DropSinkResponse")
8089            }
8090
8091            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
8092                where
8093                    V: serde::de::MapAccess<'de>,
8094            {
8095                let mut status__ = None;
8096                let mut version__ = None;
8097                while let Some(k) = map_.next_key()? {
8098                    match k {
8099                        GeneratedField::Status => {
8100                            if status__.is_some() {
8101                                return Err(serde::de::Error::duplicate_field("status"));
8102                            }
8103                            status__ = map_.next_value()?;
8104                        }
8105                        GeneratedField::Version => {
8106                            if version__.is_some() {
8107                                return Err(serde::de::Error::duplicate_field("version"));
8108                            }
8109                            version__ = map_.next_value()?;
8110                        }
8111                    }
8112                }
8113                Ok(DropSinkResponse {
8114                    status: status__,
8115                    version: version__,
8116                })
8117            }
8118        }
8119        deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
8120    }
8121}
8122impl serde::Serialize for DropSourceRequest {
8123    #[allow(deprecated)]
8124    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8125    where
8126        S: serde::Serializer,
8127    {
8128        use serde::ser::SerializeStruct;
8129        let mut len = 0;
8130        if self.source_id != 0 {
8131            len += 1;
8132        }
8133        if self.cascade {
8134            len += 1;
8135        }
8136        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
8137        if self.source_id != 0 {
8138            struct_ser.serialize_field("sourceId", &self.source_id)?;
8139        }
8140        if self.cascade {
8141            struct_ser.serialize_field("cascade", &self.cascade)?;
8142        }
8143        struct_ser.end()
8144    }
8145}
8146impl<'de> serde::Deserialize<'de> for DropSourceRequest {
8147    #[allow(deprecated)]
8148    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8149    where
8150        D: serde::Deserializer<'de>,
8151    {
8152        const FIELDS: &[&str] = &[
8153            "source_id",
8154            "sourceId",
8155            "cascade",
8156        ];
8157
8158        #[allow(clippy::enum_variant_names)]
8159        enum GeneratedField {
8160            SourceId,
8161            Cascade,
8162        }
8163        impl<'de> serde::Deserialize<'de> for GeneratedField {
8164            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8165            where
8166                D: serde::Deserializer<'de>,
8167            {
8168                struct GeneratedVisitor;
8169
8170                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8171                    type Value = GeneratedField;
8172
8173                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8174                        write!(formatter, "expected one of: {:?}", &FIELDS)
8175                    }
8176
8177                    #[allow(unused_variables)]
8178                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8179                    where
8180                        E: serde::de::Error,
8181                    {
8182                        match value {
8183                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8184                            "cascade" => Ok(GeneratedField::Cascade),
8185                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8186                        }
8187                    }
8188                }
8189                deserializer.deserialize_identifier(GeneratedVisitor)
8190            }
8191        }
8192        struct GeneratedVisitor;
8193        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8194            type Value = DropSourceRequest;
8195
8196            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8197                formatter.write_str("struct ddl_service.DropSourceRequest")
8198            }
8199
8200            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
8201                where
8202                    V: serde::de::MapAccess<'de>,
8203            {
8204                let mut source_id__ = None;
8205                let mut cascade__ = None;
8206                while let Some(k) = map_.next_key()? {
8207                    match k {
8208                        GeneratedField::SourceId => {
8209                            if source_id__.is_some() {
8210                                return Err(serde::de::Error::duplicate_field("sourceId"));
8211                            }
8212                            source_id__ = 
8213                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8214                            ;
8215                        }
8216                        GeneratedField::Cascade => {
8217                            if cascade__.is_some() {
8218                                return Err(serde::de::Error::duplicate_field("cascade"));
8219                            }
8220                            cascade__ = Some(map_.next_value()?);
8221                        }
8222                    }
8223                }
8224                Ok(DropSourceRequest {
8225                    source_id: source_id__.unwrap_or_default(),
8226                    cascade: cascade__.unwrap_or_default(),
8227                })
8228            }
8229        }
8230        deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
8231    }
8232}
8233impl serde::Serialize for DropSourceResponse {
8234    #[allow(deprecated)]
8235    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8236    where
8237        S: serde::Serializer,
8238    {
8239        use serde::ser::SerializeStruct;
8240        let mut len = 0;
8241        if self.status.is_some() {
8242            len += 1;
8243        }
8244        if self.version.is_some() {
8245            len += 1;
8246        }
8247        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
8248        if let Some(v) = self.status.as_ref() {
8249            struct_ser.serialize_field("status", v)?;
8250        }
8251        if let Some(v) = self.version.as_ref() {
8252            struct_ser.serialize_field("version", v)?;
8253        }
8254        struct_ser.end()
8255    }
8256}
8257impl<'de> serde::Deserialize<'de> for DropSourceResponse {
8258    #[allow(deprecated)]
8259    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8260    where
8261        D: serde::Deserializer<'de>,
8262    {
8263        const FIELDS: &[&str] = &[
8264            "status",
8265            "version",
8266        ];
8267
8268        #[allow(clippy::enum_variant_names)]
8269        enum GeneratedField {
8270            Status,
8271            Version,
8272        }
8273        impl<'de> serde::Deserialize<'de> for GeneratedField {
8274            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8275            where
8276                D: serde::Deserializer<'de>,
8277            {
8278                struct GeneratedVisitor;
8279
8280                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8281                    type Value = GeneratedField;
8282
8283                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8284                        write!(formatter, "expected one of: {:?}", &FIELDS)
8285                    }
8286
8287                    #[allow(unused_variables)]
8288                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8289                    where
8290                        E: serde::de::Error,
8291                    {
8292                        match value {
8293                            "status" => Ok(GeneratedField::Status),
8294                            "version" => Ok(GeneratedField::Version),
8295                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8296                        }
8297                    }
8298                }
8299                deserializer.deserialize_identifier(GeneratedVisitor)
8300            }
8301        }
8302        struct GeneratedVisitor;
8303        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8304            type Value = DropSourceResponse;
8305
8306            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8307                formatter.write_str("struct ddl_service.DropSourceResponse")
8308            }
8309
8310            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
8311                where
8312                    V: serde::de::MapAccess<'de>,
8313            {
8314                let mut status__ = None;
8315                let mut version__ = None;
8316                while let Some(k) = map_.next_key()? {
8317                    match k {
8318                        GeneratedField::Status => {
8319                            if status__.is_some() {
8320                                return Err(serde::de::Error::duplicate_field("status"));
8321                            }
8322                            status__ = map_.next_value()?;
8323                        }
8324                        GeneratedField::Version => {
8325                            if version__.is_some() {
8326                                return Err(serde::de::Error::duplicate_field("version"));
8327                            }
8328                            version__ = map_.next_value()?;
8329                        }
8330                    }
8331                }
8332                Ok(DropSourceResponse {
8333                    status: status__,
8334                    version: version__,
8335                })
8336            }
8337        }
8338        deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
8339    }
8340}
8341impl serde::Serialize for DropSubscriptionRequest {
8342    #[allow(deprecated)]
8343    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8344    where
8345        S: serde::Serializer,
8346    {
8347        use serde::ser::SerializeStruct;
8348        let mut len = 0;
8349        if self.subscription_id != 0 {
8350            len += 1;
8351        }
8352        if self.cascade {
8353            len += 1;
8354        }
8355        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
8356        if self.subscription_id != 0 {
8357            struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
8358        }
8359        if self.cascade {
8360            struct_ser.serialize_field("cascade", &self.cascade)?;
8361        }
8362        struct_ser.end()
8363    }
8364}
8365impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
8366    #[allow(deprecated)]
8367    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8368    where
8369        D: serde::Deserializer<'de>,
8370    {
8371        const FIELDS: &[&str] = &[
8372            "subscription_id",
8373            "subscriptionId",
8374            "cascade",
8375        ];
8376
8377        #[allow(clippy::enum_variant_names)]
8378        enum GeneratedField {
8379            SubscriptionId,
8380            Cascade,
8381        }
8382        impl<'de> serde::Deserialize<'de> for GeneratedField {
8383            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8384            where
8385                D: serde::Deserializer<'de>,
8386            {
8387                struct GeneratedVisitor;
8388
8389                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8390                    type Value = GeneratedField;
8391
8392                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8393                        write!(formatter, "expected one of: {:?}", &FIELDS)
8394                    }
8395
8396                    #[allow(unused_variables)]
8397                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8398                    where
8399                        E: serde::de::Error,
8400                    {
8401                        match value {
8402                            "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
8403                            "cascade" => Ok(GeneratedField::Cascade),
8404                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8405                        }
8406                    }
8407                }
8408                deserializer.deserialize_identifier(GeneratedVisitor)
8409            }
8410        }
8411        struct GeneratedVisitor;
8412        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8413            type Value = DropSubscriptionRequest;
8414
8415            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8416                formatter.write_str("struct ddl_service.DropSubscriptionRequest")
8417            }
8418
8419            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
8420                where
8421                    V: serde::de::MapAccess<'de>,
8422            {
8423                let mut subscription_id__ = None;
8424                let mut cascade__ = None;
8425                while let Some(k) = map_.next_key()? {
8426                    match k {
8427                        GeneratedField::SubscriptionId => {
8428                            if subscription_id__.is_some() {
8429                                return Err(serde::de::Error::duplicate_field("subscriptionId"));
8430                            }
8431                            subscription_id__ = 
8432                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8433                            ;
8434                        }
8435                        GeneratedField::Cascade => {
8436                            if cascade__.is_some() {
8437                                return Err(serde::de::Error::duplicate_field("cascade"));
8438                            }
8439                            cascade__ = Some(map_.next_value()?);
8440                        }
8441                    }
8442                }
8443                Ok(DropSubscriptionRequest {
8444                    subscription_id: subscription_id__.unwrap_or_default(),
8445                    cascade: cascade__.unwrap_or_default(),
8446                })
8447            }
8448        }
8449        deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
8450    }
8451}
8452impl serde::Serialize for DropSubscriptionResponse {
8453    #[allow(deprecated)]
8454    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8455    where
8456        S: serde::Serializer,
8457    {
8458        use serde::ser::SerializeStruct;
8459        let mut len = 0;
8460        if self.status.is_some() {
8461            len += 1;
8462        }
8463        if self.version.is_some() {
8464            len += 1;
8465        }
8466        let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
8467        if let Some(v) = self.status.as_ref() {
8468            struct_ser.serialize_field("status", v)?;
8469        }
8470        if let Some(v) = self.version.as_ref() {
8471            struct_ser.serialize_field("version", v)?;
8472        }
8473        struct_ser.end()
8474    }
8475}
8476impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
8477    #[allow(deprecated)]
8478    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8479    where
8480        D: serde::Deserializer<'de>,
8481    {
8482        const FIELDS: &[&str] = &[
8483            "status",
8484            "version",
8485        ];
8486
8487        #[allow(clippy::enum_variant_names)]
8488        enum GeneratedField {
8489            Status,
8490            Version,
8491        }
8492        impl<'de> serde::Deserialize<'de> for GeneratedField {
8493            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8494            where
8495                D: serde::Deserializer<'de>,
8496            {
8497                struct GeneratedVisitor;
8498
8499                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8500                    type Value = GeneratedField;
8501
8502                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8503                        write!(formatter, "expected one of: {:?}", &FIELDS)
8504                    }
8505
8506                    #[allow(unused_variables)]
8507                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8508                    where
8509                        E: serde::de::Error,
8510                    {
8511                        match value {
8512                            "status" => Ok(GeneratedField::Status),
8513                            "version" => Ok(GeneratedField::Version),
8514                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8515                        }
8516                    }
8517                }
8518                deserializer.deserialize_identifier(GeneratedVisitor)
8519            }
8520        }
8521        struct GeneratedVisitor;
8522        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8523            type Value = DropSubscriptionResponse;
8524
8525            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8526                formatter.write_str("struct ddl_service.DropSubscriptionResponse")
8527            }
8528
8529            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
8530                where
8531                    V: serde::de::MapAccess<'de>,
8532            {
8533                let mut status__ = None;
8534                let mut version__ = None;
8535                while let Some(k) = map_.next_key()? {
8536                    match k {
8537                        GeneratedField::Status => {
8538                            if status__.is_some() {
8539                                return Err(serde::de::Error::duplicate_field("status"));
8540                            }
8541                            status__ = map_.next_value()?;
8542                        }
8543                        GeneratedField::Version => {
8544                            if version__.is_some() {
8545                                return Err(serde::de::Error::duplicate_field("version"));
8546                            }
8547                            version__ = map_.next_value()?;
8548                        }
8549                    }
8550                }
8551                Ok(DropSubscriptionResponse {
8552                    status: status__,
8553                    version: version__,
8554                })
8555            }
8556        }
8557        deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
8558    }
8559}
8560impl serde::Serialize for DropTableRequest {
8561    #[allow(deprecated)]
8562    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8563    where
8564        S: serde::Serializer,
8565    {
8566        use serde::ser::SerializeStruct;
8567        let mut len = 0;
8568        if self.table_id != 0 {
8569            len += 1;
8570        }
8571        if self.cascade {
8572            len += 1;
8573        }
8574        if self.source_id.is_some() {
8575            len += 1;
8576        }
8577        let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
8578        if self.table_id != 0 {
8579            struct_ser.serialize_field("tableId", &self.table_id)?;
8580        }
8581        if self.cascade {
8582            struct_ser.serialize_field("cascade", &self.cascade)?;
8583        }
8584        if let Some(v) = self.source_id.as_ref() {
8585            match v {
8586                drop_table_request::SourceId::Id(v) => {
8587                    struct_ser.serialize_field("id", v)?;
8588                }
8589            }
8590        }
8591        struct_ser.end()
8592    }
8593}
8594impl<'de> serde::Deserialize<'de> for DropTableRequest {
8595    #[allow(deprecated)]
8596    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8597    where
8598        D: serde::Deserializer<'de>,
8599    {
8600        const FIELDS: &[&str] = &[
8601            "table_id",
8602            "tableId",
8603            "cascade",
8604            "id",
8605        ];
8606
8607        #[allow(clippy::enum_variant_names)]
8608        enum GeneratedField {
8609            TableId,
8610            Cascade,
8611            Id,
8612        }
8613        impl<'de> serde::Deserialize<'de> for GeneratedField {
8614            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8615            where
8616                D: serde::Deserializer<'de>,
8617            {
8618                struct GeneratedVisitor;
8619
8620                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8621                    type Value = GeneratedField;
8622
8623                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8624                        write!(formatter, "expected one of: {:?}", &FIELDS)
8625                    }
8626
8627                    #[allow(unused_variables)]
8628                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8629                    where
8630                        E: serde::de::Error,
8631                    {
8632                        match value {
8633                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
8634                            "cascade" => Ok(GeneratedField::Cascade),
8635                            "id" => Ok(GeneratedField::Id),
8636                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8637                        }
8638                    }
8639                }
8640                deserializer.deserialize_identifier(GeneratedVisitor)
8641            }
8642        }
8643        struct GeneratedVisitor;
8644        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8645            type Value = DropTableRequest;
8646
8647            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8648                formatter.write_str("struct ddl_service.DropTableRequest")
8649            }
8650
8651            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
8652                where
8653                    V: serde::de::MapAccess<'de>,
8654            {
8655                let mut table_id__ = None;
8656                let mut cascade__ = None;
8657                let mut source_id__ = None;
8658                while let Some(k) = map_.next_key()? {
8659                    match k {
8660                        GeneratedField::TableId => {
8661                            if table_id__.is_some() {
8662                                return Err(serde::de::Error::duplicate_field("tableId"));
8663                            }
8664                            table_id__ = 
8665                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8666                            ;
8667                        }
8668                        GeneratedField::Cascade => {
8669                            if cascade__.is_some() {
8670                                return Err(serde::de::Error::duplicate_field("cascade"));
8671                            }
8672                            cascade__ = Some(map_.next_value()?);
8673                        }
8674                        GeneratedField::Id => {
8675                            if source_id__.is_some() {
8676                                return Err(serde::de::Error::duplicate_field("id"));
8677                            }
8678                            source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
8679                        }
8680                    }
8681                }
8682                Ok(DropTableRequest {
8683                    table_id: table_id__.unwrap_or_default(),
8684                    cascade: cascade__.unwrap_or_default(),
8685                    source_id: source_id__,
8686                })
8687            }
8688        }
8689        deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
8690    }
8691}
8692impl serde::Serialize for DropTableResponse {
8693    #[allow(deprecated)]
8694    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8695    where
8696        S: serde::Serializer,
8697    {
8698        use serde::ser::SerializeStruct;
8699        let mut len = 0;
8700        if self.status.is_some() {
8701            len += 1;
8702        }
8703        if self.version.is_some() {
8704            len += 1;
8705        }
8706        let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
8707        if let Some(v) = self.status.as_ref() {
8708            struct_ser.serialize_field("status", v)?;
8709        }
8710        if let Some(v) = self.version.as_ref() {
8711            struct_ser.serialize_field("version", v)?;
8712        }
8713        struct_ser.end()
8714    }
8715}
8716impl<'de> serde::Deserialize<'de> for DropTableResponse {
8717    #[allow(deprecated)]
8718    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8719    where
8720        D: serde::Deserializer<'de>,
8721    {
8722        const FIELDS: &[&str] = &[
8723            "status",
8724            "version",
8725        ];
8726
8727        #[allow(clippy::enum_variant_names)]
8728        enum GeneratedField {
8729            Status,
8730            Version,
8731        }
8732        impl<'de> serde::Deserialize<'de> for GeneratedField {
8733            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8734            where
8735                D: serde::Deserializer<'de>,
8736            {
8737                struct GeneratedVisitor;
8738
8739                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8740                    type Value = GeneratedField;
8741
8742                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8743                        write!(formatter, "expected one of: {:?}", &FIELDS)
8744                    }
8745
8746                    #[allow(unused_variables)]
8747                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8748                    where
8749                        E: serde::de::Error,
8750                    {
8751                        match value {
8752                            "status" => Ok(GeneratedField::Status),
8753                            "version" => Ok(GeneratedField::Version),
8754                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8755                        }
8756                    }
8757                }
8758                deserializer.deserialize_identifier(GeneratedVisitor)
8759            }
8760        }
8761        struct GeneratedVisitor;
8762        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8763            type Value = DropTableResponse;
8764
8765            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8766                formatter.write_str("struct ddl_service.DropTableResponse")
8767            }
8768
8769            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
8770                where
8771                    V: serde::de::MapAccess<'de>,
8772            {
8773                let mut status__ = None;
8774                let mut version__ = None;
8775                while let Some(k) = map_.next_key()? {
8776                    match k {
8777                        GeneratedField::Status => {
8778                            if status__.is_some() {
8779                                return Err(serde::de::Error::duplicate_field("status"));
8780                            }
8781                            status__ = map_.next_value()?;
8782                        }
8783                        GeneratedField::Version => {
8784                            if version__.is_some() {
8785                                return Err(serde::de::Error::duplicate_field("version"));
8786                            }
8787                            version__ = map_.next_value()?;
8788                        }
8789                    }
8790                }
8791                Ok(DropTableResponse {
8792                    status: status__,
8793                    version: version__,
8794                })
8795            }
8796        }
8797        deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
8798    }
8799}
8800impl serde::Serialize for DropViewRequest {
8801    #[allow(deprecated)]
8802    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8803    where
8804        S: serde::Serializer,
8805    {
8806        use serde::ser::SerializeStruct;
8807        let mut len = 0;
8808        if self.view_id != 0 {
8809            len += 1;
8810        }
8811        if self.cascade {
8812            len += 1;
8813        }
8814        let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
8815        if self.view_id != 0 {
8816            struct_ser.serialize_field("viewId", &self.view_id)?;
8817        }
8818        if self.cascade {
8819            struct_ser.serialize_field("cascade", &self.cascade)?;
8820        }
8821        struct_ser.end()
8822    }
8823}
8824impl<'de> serde::Deserialize<'de> for DropViewRequest {
8825    #[allow(deprecated)]
8826    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8827    where
8828        D: serde::Deserializer<'de>,
8829    {
8830        const FIELDS: &[&str] = &[
8831            "view_id",
8832            "viewId",
8833            "cascade",
8834        ];
8835
8836        #[allow(clippy::enum_variant_names)]
8837        enum GeneratedField {
8838            ViewId,
8839            Cascade,
8840        }
8841        impl<'de> serde::Deserialize<'de> for GeneratedField {
8842            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8843            where
8844                D: serde::Deserializer<'de>,
8845            {
8846                struct GeneratedVisitor;
8847
8848                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8849                    type Value = GeneratedField;
8850
8851                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8852                        write!(formatter, "expected one of: {:?}", &FIELDS)
8853                    }
8854
8855                    #[allow(unused_variables)]
8856                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8857                    where
8858                        E: serde::de::Error,
8859                    {
8860                        match value {
8861                            "viewId" | "view_id" => Ok(GeneratedField::ViewId),
8862                            "cascade" => Ok(GeneratedField::Cascade),
8863                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8864                        }
8865                    }
8866                }
8867                deserializer.deserialize_identifier(GeneratedVisitor)
8868            }
8869        }
8870        struct GeneratedVisitor;
8871        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8872            type Value = DropViewRequest;
8873
8874            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8875                formatter.write_str("struct ddl_service.DropViewRequest")
8876            }
8877
8878            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
8879                where
8880                    V: serde::de::MapAccess<'de>,
8881            {
8882                let mut view_id__ = None;
8883                let mut cascade__ = None;
8884                while let Some(k) = map_.next_key()? {
8885                    match k {
8886                        GeneratedField::ViewId => {
8887                            if view_id__.is_some() {
8888                                return Err(serde::de::Error::duplicate_field("viewId"));
8889                            }
8890                            view_id__ = 
8891                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8892                            ;
8893                        }
8894                        GeneratedField::Cascade => {
8895                            if cascade__.is_some() {
8896                                return Err(serde::de::Error::duplicate_field("cascade"));
8897                            }
8898                            cascade__ = Some(map_.next_value()?);
8899                        }
8900                    }
8901                }
8902                Ok(DropViewRequest {
8903                    view_id: view_id__.unwrap_or_default(),
8904                    cascade: cascade__.unwrap_or_default(),
8905                })
8906            }
8907        }
8908        deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
8909    }
8910}
8911impl serde::Serialize for DropViewResponse {
8912    #[allow(deprecated)]
8913    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8914    where
8915        S: serde::Serializer,
8916    {
8917        use serde::ser::SerializeStruct;
8918        let mut len = 0;
8919        if self.status.is_some() {
8920            len += 1;
8921        }
8922        if self.version.is_some() {
8923            len += 1;
8924        }
8925        let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
8926        if let Some(v) = self.status.as_ref() {
8927            struct_ser.serialize_field("status", v)?;
8928        }
8929        if let Some(v) = self.version.as_ref() {
8930            struct_ser.serialize_field("version", v)?;
8931        }
8932        struct_ser.end()
8933    }
8934}
8935impl<'de> serde::Deserialize<'de> for DropViewResponse {
8936    #[allow(deprecated)]
8937    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8938    where
8939        D: serde::Deserializer<'de>,
8940    {
8941        const FIELDS: &[&str] = &[
8942            "status",
8943            "version",
8944        ];
8945
8946        #[allow(clippy::enum_variant_names)]
8947        enum GeneratedField {
8948            Status,
8949            Version,
8950        }
8951        impl<'de> serde::Deserialize<'de> for GeneratedField {
8952            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8953            where
8954                D: serde::Deserializer<'de>,
8955            {
8956                struct GeneratedVisitor;
8957
8958                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8959                    type Value = GeneratedField;
8960
8961                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8962                        write!(formatter, "expected one of: {:?}", &FIELDS)
8963                    }
8964
8965                    #[allow(unused_variables)]
8966                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8967                    where
8968                        E: serde::de::Error,
8969                    {
8970                        match value {
8971                            "status" => Ok(GeneratedField::Status),
8972                            "version" => Ok(GeneratedField::Version),
8973                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8974                        }
8975                    }
8976                }
8977                deserializer.deserialize_identifier(GeneratedVisitor)
8978            }
8979        }
8980        struct GeneratedVisitor;
8981        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8982            type Value = DropViewResponse;
8983
8984            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8985                formatter.write_str("struct ddl_service.DropViewResponse")
8986            }
8987
8988            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
8989                where
8990                    V: serde::de::MapAccess<'de>,
8991            {
8992                let mut status__ = None;
8993                let mut version__ = None;
8994                while let Some(k) = map_.next_key()? {
8995                    match k {
8996                        GeneratedField::Status => {
8997                            if status__.is_some() {
8998                                return Err(serde::de::Error::duplicate_field("status"));
8999                            }
9000                            status__ = map_.next_value()?;
9001                        }
9002                        GeneratedField::Version => {
9003                            if version__.is_some() {
9004                                return Err(serde::de::Error::duplicate_field("version"));
9005                            }
9006                            version__ = map_.next_value()?;
9007                        }
9008                    }
9009                }
9010                Ok(DropViewResponse {
9011                    status: status__,
9012                    version: version__,
9013                })
9014            }
9015        }
9016        deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
9017    }
9018}
9019impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
9020    #[allow(deprecated)]
9021    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9022    where
9023        S: serde::Serializer,
9024    {
9025        use serde::ser::SerializeStruct;
9026        let mut len = 0;
9027        if self.sink_id != 0 {
9028            len += 1;
9029        }
9030        let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
9031        if self.sink_id != 0 {
9032            struct_ser.serialize_field("sinkId", &self.sink_id)?;
9033        }
9034        struct_ser.end()
9035    }
9036}
9037impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
9038    #[allow(deprecated)]
9039    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9040    where
9041        D: serde::Deserializer<'de>,
9042    {
9043        const FIELDS: &[&str] = &[
9044            "sink_id",
9045            "sinkId",
9046        ];
9047
9048        #[allow(clippy::enum_variant_names)]
9049        enum GeneratedField {
9050            SinkId,
9051        }
9052        impl<'de> serde::Deserialize<'de> for GeneratedField {
9053            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9054            where
9055                D: serde::Deserializer<'de>,
9056            {
9057                struct GeneratedVisitor;
9058
9059                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9060                    type Value = GeneratedField;
9061
9062                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9063                        write!(formatter, "expected one of: {:?}", &FIELDS)
9064                    }
9065
9066                    #[allow(unused_variables)]
9067                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9068                    where
9069                        E: serde::de::Error,
9070                    {
9071                        match value {
9072                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9073                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9074                        }
9075                    }
9076                }
9077                deserializer.deserialize_identifier(GeneratedVisitor)
9078            }
9079        }
9080        struct GeneratedVisitor;
9081        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9082            type Value = ExpireIcebergTableSnapshotsRequest;
9083
9084            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9085                formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
9086            }
9087
9088            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
9089                where
9090                    V: serde::de::MapAccess<'de>,
9091            {
9092                let mut sink_id__ = None;
9093                while let Some(k) = map_.next_key()? {
9094                    match k {
9095                        GeneratedField::SinkId => {
9096                            if sink_id__.is_some() {
9097                                return Err(serde::de::Error::duplicate_field("sinkId"));
9098                            }
9099                            sink_id__ = 
9100                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9101                            ;
9102                        }
9103                    }
9104                }
9105                Ok(ExpireIcebergTableSnapshotsRequest {
9106                    sink_id: sink_id__.unwrap_or_default(),
9107                })
9108            }
9109        }
9110        deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
9111    }
9112}
9113impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
9114    #[allow(deprecated)]
9115    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9116    where
9117        S: serde::Serializer,
9118    {
9119        use serde::ser::SerializeStruct;
9120        let mut len = 0;
9121        if self.status.is_some() {
9122            len += 1;
9123        }
9124        let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
9125        if let Some(v) = self.status.as_ref() {
9126            struct_ser.serialize_field("status", v)?;
9127        }
9128        struct_ser.end()
9129    }
9130}
9131impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
9132    #[allow(deprecated)]
9133    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9134    where
9135        D: serde::Deserializer<'de>,
9136    {
9137        const FIELDS: &[&str] = &[
9138            "status",
9139        ];
9140
9141        #[allow(clippy::enum_variant_names)]
9142        enum GeneratedField {
9143            Status,
9144        }
9145        impl<'de> serde::Deserialize<'de> for GeneratedField {
9146            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9147            where
9148                D: serde::Deserializer<'de>,
9149            {
9150                struct GeneratedVisitor;
9151
9152                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9153                    type Value = GeneratedField;
9154
9155                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9156                        write!(formatter, "expected one of: {:?}", &FIELDS)
9157                    }
9158
9159                    #[allow(unused_variables)]
9160                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9161                    where
9162                        E: serde::de::Error,
9163                    {
9164                        match value {
9165                            "status" => Ok(GeneratedField::Status),
9166                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9167                        }
9168                    }
9169                }
9170                deserializer.deserialize_identifier(GeneratedVisitor)
9171            }
9172        }
9173        struct GeneratedVisitor;
9174        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9175            type Value = ExpireIcebergTableSnapshotsResponse;
9176
9177            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9178                formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
9179            }
9180
9181            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
9182                where
9183                    V: serde::de::MapAccess<'de>,
9184            {
9185                let mut status__ = None;
9186                while let Some(k) = map_.next_key()? {
9187                    match k {
9188                        GeneratedField::Status => {
9189                            if status__.is_some() {
9190                                return Err(serde::de::Error::duplicate_field("status"));
9191                            }
9192                            status__ = map_.next_value()?;
9193                        }
9194                    }
9195                }
9196                Ok(ExpireIcebergTableSnapshotsResponse {
9197                    status: status__,
9198                })
9199            }
9200        }
9201        deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
9202    }
9203}
9204impl serde::Serialize for GetDdlProgressRequest {
9205    #[allow(deprecated)]
9206    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9207    where
9208        S: serde::Serializer,
9209    {
9210        use serde::ser::SerializeStruct;
9211        let len = 0;
9212        let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
9213        struct_ser.end()
9214    }
9215}
9216impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
9217    #[allow(deprecated)]
9218    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9219    where
9220        D: serde::Deserializer<'de>,
9221    {
9222        const FIELDS: &[&str] = &[
9223        ];
9224
9225        #[allow(clippy::enum_variant_names)]
9226        enum GeneratedField {
9227        }
9228        impl<'de> serde::Deserialize<'de> for GeneratedField {
9229            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9230            where
9231                D: serde::Deserializer<'de>,
9232            {
9233                struct GeneratedVisitor;
9234
9235                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9236                    type Value = GeneratedField;
9237
9238                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9239                        write!(formatter, "expected one of: {:?}", &FIELDS)
9240                    }
9241
9242                    #[allow(unused_variables)]
9243                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9244                    where
9245                        E: serde::de::Error,
9246                    {
9247                            Err(serde::de::Error::unknown_field(value, FIELDS))
9248                    }
9249                }
9250                deserializer.deserialize_identifier(GeneratedVisitor)
9251            }
9252        }
9253        struct GeneratedVisitor;
9254        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9255            type Value = GetDdlProgressRequest;
9256
9257            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9258                formatter.write_str("struct ddl_service.GetDdlProgressRequest")
9259            }
9260
9261            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
9262                where
9263                    V: serde::de::MapAccess<'de>,
9264            {
9265                while map_.next_key::<GeneratedField>()?.is_some() {
9266                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9267                }
9268                Ok(GetDdlProgressRequest {
9269                })
9270            }
9271        }
9272        deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
9273    }
9274}
9275impl serde::Serialize for GetDdlProgressResponse {
9276    #[allow(deprecated)]
9277    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9278    where
9279        S: serde::Serializer,
9280    {
9281        use serde::ser::SerializeStruct;
9282        let mut len = 0;
9283        if !self.ddl_progress.is_empty() {
9284            len += 1;
9285        }
9286        let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
9287        if !self.ddl_progress.is_empty() {
9288            struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
9289        }
9290        struct_ser.end()
9291    }
9292}
9293impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
9294    #[allow(deprecated)]
9295    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9296    where
9297        D: serde::Deserializer<'de>,
9298    {
9299        const FIELDS: &[&str] = &[
9300            "ddl_progress",
9301            "ddlProgress",
9302        ];
9303
9304        #[allow(clippy::enum_variant_names)]
9305        enum GeneratedField {
9306            DdlProgress,
9307        }
9308        impl<'de> serde::Deserialize<'de> for GeneratedField {
9309            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9310            where
9311                D: serde::Deserializer<'de>,
9312            {
9313                struct GeneratedVisitor;
9314
9315                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9316                    type Value = GeneratedField;
9317
9318                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9319                        write!(formatter, "expected one of: {:?}", &FIELDS)
9320                    }
9321
9322                    #[allow(unused_variables)]
9323                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9324                    where
9325                        E: serde::de::Error,
9326                    {
9327                        match value {
9328                            "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
9329                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9330                        }
9331                    }
9332                }
9333                deserializer.deserialize_identifier(GeneratedVisitor)
9334            }
9335        }
9336        struct GeneratedVisitor;
9337        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9338            type Value = GetDdlProgressResponse;
9339
9340            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9341                formatter.write_str("struct ddl_service.GetDdlProgressResponse")
9342            }
9343
9344            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
9345                where
9346                    V: serde::de::MapAccess<'de>,
9347            {
9348                let mut ddl_progress__ = None;
9349                while let Some(k) = map_.next_key()? {
9350                    match k {
9351                        GeneratedField::DdlProgress => {
9352                            if ddl_progress__.is_some() {
9353                                return Err(serde::de::Error::duplicate_field("ddlProgress"));
9354                            }
9355                            ddl_progress__ = Some(map_.next_value()?);
9356                        }
9357                    }
9358                }
9359                Ok(GetDdlProgressResponse {
9360                    ddl_progress: ddl_progress__.unwrap_or_default(),
9361                })
9362            }
9363        }
9364        deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
9365    }
9366}
9367impl serde::Serialize for GetTableRequest {
9368    #[allow(deprecated)]
9369    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9370    where
9371        S: serde::Serializer,
9372    {
9373        use serde::ser::SerializeStruct;
9374        let mut len = 0;
9375        if !self.database_name.is_empty() {
9376            len += 1;
9377        }
9378        if !self.table_name.is_empty() {
9379            len += 1;
9380        }
9381        let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
9382        if !self.database_name.is_empty() {
9383            struct_ser.serialize_field("databaseName", &self.database_name)?;
9384        }
9385        if !self.table_name.is_empty() {
9386            struct_ser.serialize_field("tableName", &self.table_name)?;
9387        }
9388        struct_ser.end()
9389    }
9390}
9391impl<'de> serde::Deserialize<'de> for GetTableRequest {
9392    #[allow(deprecated)]
9393    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9394    where
9395        D: serde::Deserializer<'de>,
9396    {
9397        const FIELDS: &[&str] = &[
9398            "database_name",
9399            "databaseName",
9400            "table_name",
9401            "tableName",
9402        ];
9403
9404        #[allow(clippy::enum_variant_names)]
9405        enum GeneratedField {
9406            DatabaseName,
9407            TableName,
9408        }
9409        impl<'de> serde::Deserialize<'de> for GeneratedField {
9410            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9411            where
9412                D: serde::Deserializer<'de>,
9413            {
9414                struct GeneratedVisitor;
9415
9416                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9417                    type Value = GeneratedField;
9418
9419                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9420                        write!(formatter, "expected one of: {:?}", &FIELDS)
9421                    }
9422
9423                    #[allow(unused_variables)]
9424                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9425                    where
9426                        E: serde::de::Error,
9427                    {
9428                        match value {
9429                            "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
9430                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
9431                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9432                        }
9433                    }
9434                }
9435                deserializer.deserialize_identifier(GeneratedVisitor)
9436            }
9437        }
9438        struct GeneratedVisitor;
9439        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9440            type Value = GetTableRequest;
9441
9442            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9443                formatter.write_str("struct ddl_service.GetTableRequest")
9444            }
9445
9446            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
9447                where
9448                    V: serde::de::MapAccess<'de>,
9449            {
9450                let mut database_name__ = None;
9451                let mut table_name__ = None;
9452                while let Some(k) = map_.next_key()? {
9453                    match k {
9454                        GeneratedField::DatabaseName => {
9455                            if database_name__.is_some() {
9456                                return Err(serde::de::Error::duplicate_field("databaseName"));
9457                            }
9458                            database_name__ = Some(map_.next_value()?);
9459                        }
9460                        GeneratedField::TableName => {
9461                            if table_name__.is_some() {
9462                                return Err(serde::de::Error::duplicate_field("tableName"));
9463                            }
9464                            table_name__ = Some(map_.next_value()?);
9465                        }
9466                    }
9467                }
9468                Ok(GetTableRequest {
9469                    database_name: database_name__.unwrap_or_default(),
9470                    table_name: table_name__.unwrap_or_default(),
9471                })
9472            }
9473        }
9474        deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
9475    }
9476}
9477impl serde::Serialize for GetTableResponse {
9478    #[allow(deprecated)]
9479    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9480    where
9481        S: serde::Serializer,
9482    {
9483        use serde::ser::SerializeStruct;
9484        let mut len = 0;
9485        if self.table.is_some() {
9486            len += 1;
9487        }
9488        let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
9489        if let Some(v) = self.table.as_ref() {
9490            struct_ser.serialize_field("table", v)?;
9491        }
9492        struct_ser.end()
9493    }
9494}
9495impl<'de> serde::Deserialize<'de> for GetTableResponse {
9496    #[allow(deprecated)]
9497    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9498    where
9499        D: serde::Deserializer<'de>,
9500    {
9501        const FIELDS: &[&str] = &[
9502            "table",
9503        ];
9504
9505        #[allow(clippy::enum_variant_names)]
9506        enum GeneratedField {
9507            Table,
9508        }
9509        impl<'de> serde::Deserialize<'de> for GeneratedField {
9510            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9511            where
9512                D: serde::Deserializer<'de>,
9513            {
9514                struct GeneratedVisitor;
9515
9516                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9517                    type Value = GeneratedField;
9518
9519                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9520                        write!(formatter, "expected one of: {:?}", &FIELDS)
9521                    }
9522
9523                    #[allow(unused_variables)]
9524                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9525                    where
9526                        E: serde::de::Error,
9527                    {
9528                        match value {
9529                            "table" => Ok(GeneratedField::Table),
9530                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9531                        }
9532                    }
9533                }
9534                deserializer.deserialize_identifier(GeneratedVisitor)
9535            }
9536        }
9537        struct GeneratedVisitor;
9538        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9539            type Value = GetTableResponse;
9540
9541            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9542                formatter.write_str("struct ddl_service.GetTableResponse")
9543            }
9544
9545            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
9546                where
9547                    V: serde::de::MapAccess<'de>,
9548            {
9549                let mut table__ = None;
9550                while let Some(k) = map_.next_key()? {
9551                    match k {
9552                        GeneratedField::Table => {
9553                            if table__.is_some() {
9554                                return Err(serde::de::Error::duplicate_field("table"));
9555                            }
9556                            table__ = map_.next_value()?;
9557                        }
9558                    }
9559                }
9560                Ok(GetTableResponse {
9561                    table: table__,
9562                })
9563            }
9564        }
9565        deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
9566    }
9567}
9568impl serde::Serialize for GetTablesRequest {
9569    #[allow(deprecated)]
9570    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9571    where
9572        S: serde::Serializer,
9573    {
9574        use serde::ser::SerializeStruct;
9575        let mut len = 0;
9576        if !self.table_ids.is_empty() {
9577            len += 1;
9578        }
9579        if self.include_dropped_tables {
9580            len += 1;
9581        }
9582        let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
9583        if !self.table_ids.is_empty() {
9584            struct_ser.serialize_field("tableIds", &self.table_ids)?;
9585        }
9586        if self.include_dropped_tables {
9587            struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
9588        }
9589        struct_ser.end()
9590    }
9591}
9592impl<'de> serde::Deserialize<'de> for GetTablesRequest {
9593    #[allow(deprecated)]
9594    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9595    where
9596        D: serde::Deserializer<'de>,
9597    {
9598        const FIELDS: &[&str] = &[
9599            "table_ids",
9600            "tableIds",
9601            "include_dropped_tables",
9602            "includeDroppedTables",
9603        ];
9604
9605        #[allow(clippy::enum_variant_names)]
9606        enum GeneratedField {
9607            TableIds,
9608            IncludeDroppedTables,
9609        }
9610        impl<'de> serde::Deserialize<'de> for GeneratedField {
9611            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9612            where
9613                D: serde::Deserializer<'de>,
9614            {
9615                struct GeneratedVisitor;
9616
9617                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9618                    type Value = GeneratedField;
9619
9620                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9621                        write!(formatter, "expected one of: {:?}", &FIELDS)
9622                    }
9623
9624                    #[allow(unused_variables)]
9625                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9626                    where
9627                        E: serde::de::Error,
9628                    {
9629                        match value {
9630                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
9631                            "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
9632                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9633                        }
9634                    }
9635                }
9636                deserializer.deserialize_identifier(GeneratedVisitor)
9637            }
9638        }
9639        struct GeneratedVisitor;
9640        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9641            type Value = GetTablesRequest;
9642
9643            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9644                formatter.write_str("struct ddl_service.GetTablesRequest")
9645            }
9646
9647            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
9648                where
9649                    V: serde::de::MapAccess<'de>,
9650            {
9651                let mut table_ids__ = None;
9652                let mut include_dropped_tables__ = None;
9653                while let Some(k) = map_.next_key()? {
9654                    match k {
9655                        GeneratedField::TableIds => {
9656                            if table_ids__.is_some() {
9657                                return Err(serde::de::Error::duplicate_field("tableIds"));
9658                            }
9659                            table_ids__ = 
9660                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9661                                    .into_iter().map(|x| x.0).collect())
9662                            ;
9663                        }
9664                        GeneratedField::IncludeDroppedTables => {
9665                            if include_dropped_tables__.is_some() {
9666                                return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
9667                            }
9668                            include_dropped_tables__ = Some(map_.next_value()?);
9669                        }
9670                    }
9671                }
9672                Ok(GetTablesRequest {
9673                    table_ids: table_ids__.unwrap_or_default(),
9674                    include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
9675                })
9676            }
9677        }
9678        deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
9679    }
9680}
9681impl serde::Serialize for GetTablesResponse {
9682    #[allow(deprecated)]
9683    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9684    where
9685        S: serde::Serializer,
9686    {
9687        use serde::ser::SerializeStruct;
9688        let mut len = 0;
9689        if !self.tables.is_empty() {
9690            len += 1;
9691        }
9692        let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
9693        if !self.tables.is_empty() {
9694            struct_ser.serialize_field("tables", &self.tables)?;
9695        }
9696        struct_ser.end()
9697    }
9698}
9699impl<'de> serde::Deserialize<'de> for GetTablesResponse {
9700    #[allow(deprecated)]
9701    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9702    where
9703        D: serde::Deserializer<'de>,
9704    {
9705        const FIELDS: &[&str] = &[
9706            "tables",
9707        ];
9708
9709        #[allow(clippy::enum_variant_names)]
9710        enum GeneratedField {
9711            Tables,
9712        }
9713        impl<'de> serde::Deserialize<'de> for GeneratedField {
9714            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9715            where
9716                D: serde::Deserializer<'de>,
9717            {
9718                struct GeneratedVisitor;
9719
9720                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9721                    type Value = GeneratedField;
9722
9723                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9724                        write!(formatter, "expected one of: {:?}", &FIELDS)
9725                    }
9726
9727                    #[allow(unused_variables)]
9728                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9729                    where
9730                        E: serde::de::Error,
9731                    {
9732                        match value {
9733                            "tables" => Ok(GeneratedField::Tables),
9734                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9735                        }
9736                    }
9737                }
9738                deserializer.deserialize_identifier(GeneratedVisitor)
9739            }
9740        }
9741        struct GeneratedVisitor;
9742        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9743            type Value = GetTablesResponse;
9744
9745            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9746                formatter.write_str("struct ddl_service.GetTablesResponse")
9747            }
9748
9749            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
9750                where
9751                    V: serde::de::MapAccess<'de>,
9752            {
9753                let mut tables__ = None;
9754                while let Some(k) = map_.next_key()? {
9755                    match k {
9756                        GeneratedField::Tables => {
9757                            if tables__.is_some() {
9758                                return Err(serde::de::Error::duplicate_field("tables"));
9759                            }
9760                            tables__ = Some(
9761                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9762                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
9763                            );
9764                        }
9765                    }
9766                }
9767                Ok(GetTablesResponse {
9768                    tables: tables__.unwrap_or_default(),
9769                })
9770            }
9771        }
9772        deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
9773    }
9774}
9775impl serde::Serialize for ListConnectionsRequest {
9776    #[allow(deprecated)]
9777    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9778    where
9779        S: serde::Serializer,
9780    {
9781        use serde::ser::SerializeStruct;
9782        let len = 0;
9783        let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
9784        struct_ser.end()
9785    }
9786}
9787impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
9788    #[allow(deprecated)]
9789    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9790    where
9791        D: serde::Deserializer<'de>,
9792    {
9793        const FIELDS: &[&str] = &[
9794        ];
9795
9796        #[allow(clippy::enum_variant_names)]
9797        enum GeneratedField {
9798        }
9799        impl<'de> serde::Deserialize<'de> for GeneratedField {
9800            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9801            where
9802                D: serde::Deserializer<'de>,
9803            {
9804                struct GeneratedVisitor;
9805
9806                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9807                    type Value = GeneratedField;
9808
9809                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9810                        write!(formatter, "expected one of: {:?}", &FIELDS)
9811                    }
9812
9813                    #[allow(unused_variables)]
9814                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9815                    where
9816                        E: serde::de::Error,
9817                    {
9818                            Err(serde::de::Error::unknown_field(value, FIELDS))
9819                    }
9820                }
9821                deserializer.deserialize_identifier(GeneratedVisitor)
9822            }
9823        }
9824        struct GeneratedVisitor;
9825        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9826            type Value = ListConnectionsRequest;
9827
9828            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9829                formatter.write_str("struct ddl_service.ListConnectionsRequest")
9830            }
9831
9832            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
9833                where
9834                    V: serde::de::MapAccess<'de>,
9835            {
9836                while map_.next_key::<GeneratedField>()?.is_some() {
9837                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9838                }
9839                Ok(ListConnectionsRequest {
9840                })
9841            }
9842        }
9843        deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
9844    }
9845}
9846impl serde::Serialize for ListConnectionsResponse {
9847    #[allow(deprecated)]
9848    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9849    where
9850        S: serde::Serializer,
9851    {
9852        use serde::ser::SerializeStruct;
9853        let mut len = 0;
9854        if !self.connections.is_empty() {
9855            len += 1;
9856        }
9857        let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
9858        if !self.connections.is_empty() {
9859            struct_ser.serialize_field("connections", &self.connections)?;
9860        }
9861        struct_ser.end()
9862    }
9863}
9864impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
9865    #[allow(deprecated)]
9866    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9867    where
9868        D: serde::Deserializer<'de>,
9869    {
9870        const FIELDS: &[&str] = &[
9871            "connections",
9872        ];
9873
9874        #[allow(clippy::enum_variant_names)]
9875        enum GeneratedField {
9876            Connections,
9877        }
9878        impl<'de> serde::Deserialize<'de> for GeneratedField {
9879            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9880            where
9881                D: serde::Deserializer<'de>,
9882            {
9883                struct GeneratedVisitor;
9884
9885                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9886                    type Value = GeneratedField;
9887
9888                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9889                        write!(formatter, "expected one of: {:?}", &FIELDS)
9890                    }
9891
9892                    #[allow(unused_variables)]
9893                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9894                    where
9895                        E: serde::de::Error,
9896                    {
9897                        match value {
9898                            "connections" => Ok(GeneratedField::Connections),
9899                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9900                        }
9901                    }
9902                }
9903                deserializer.deserialize_identifier(GeneratedVisitor)
9904            }
9905        }
9906        struct GeneratedVisitor;
9907        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9908            type Value = ListConnectionsResponse;
9909
9910            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9911                formatter.write_str("struct ddl_service.ListConnectionsResponse")
9912            }
9913
9914            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
9915                where
9916                    V: serde::de::MapAccess<'de>,
9917            {
9918                let mut connections__ = None;
9919                while let Some(k) = map_.next_key()? {
9920                    match k {
9921                        GeneratedField::Connections => {
9922                            if connections__.is_some() {
9923                                return Err(serde::de::Error::duplicate_field("connections"));
9924                            }
9925                            connections__ = Some(map_.next_value()?);
9926                        }
9927                    }
9928                }
9929                Ok(ListConnectionsResponse {
9930                    connections: connections__.unwrap_or_default(),
9931                })
9932            }
9933        }
9934        deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
9935    }
9936}
9937impl serde::Serialize for ReplaceJobPlan {
9938    #[allow(deprecated)]
9939    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9940    where
9941        S: serde::Serializer,
9942    {
9943        use serde::ser::SerializeStruct;
9944        let mut len = 0;
9945        if self.fragment_graph.is_some() {
9946            len += 1;
9947        }
9948        if self.replace_job.is_some() {
9949            len += 1;
9950        }
9951        let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
9952        if let Some(v) = self.fragment_graph.as_ref() {
9953            struct_ser.serialize_field("fragmentGraph", v)?;
9954        }
9955        if let Some(v) = self.replace_job.as_ref() {
9956            match v {
9957                replace_job_plan::ReplaceJob::ReplaceTable(v) => {
9958                    struct_ser.serialize_field("replaceTable", v)?;
9959                }
9960                replace_job_plan::ReplaceJob::ReplaceSource(v) => {
9961                    struct_ser.serialize_field("replaceSource", v)?;
9962                }
9963                replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
9964                    struct_ser.serialize_field("replaceMaterializedView", v)?;
9965                }
9966            }
9967        }
9968        struct_ser.end()
9969    }
9970}
9971impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
9972    #[allow(deprecated)]
9973    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9974    where
9975        D: serde::Deserializer<'de>,
9976    {
9977        const FIELDS: &[&str] = &[
9978            "fragment_graph",
9979            "fragmentGraph",
9980            "replace_table",
9981            "replaceTable",
9982            "replace_source",
9983            "replaceSource",
9984            "replace_materialized_view",
9985            "replaceMaterializedView",
9986        ];
9987
9988        #[allow(clippy::enum_variant_names)]
9989        enum GeneratedField {
9990            FragmentGraph,
9991            ReplaceTable,
9992            ReplaceSource,
9993            ReplaceMaterializedView,
9994        }
9995        impl<'de> serde::Deserialize<'de> for GeneratedField {
9996            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9997            where
9998                D: serde::Deserializer<'de>,
9999            {
10000                struct GeneratedVisitor;
10001
10002                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10003                    type Value = GeneratedField;
10004
10005                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10006                        write!(formatter, "expected one of: {:?}", &FIELDS)
10007                    }
10008
10009                    #[allow(unused_variables)]
10010                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10011                    where
10012                        E: serde::de::Error,
10013                    {
10014                        match value {
10015                            "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
10016                            "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
10017                            "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
10018                            "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
10019                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10020                        }
10021                    }
10022                }
10023                deserializer.deserialize_identifier(GeneratedVisitor)
10024            }
10025        }
10026        struct GeneratedVisitor;
10027        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10028            type Value = ReplaceJobPlan;
10029
10030            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10031                formatter.write_str("struct ddl_service.ReplaceJobPlan")
10032            }
10033
10034            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
10035                where
10036                    V: serde::de::MapAccess<'de>,
10037            {
10038                let mut fragment_graph__ = None;
10039                let mut replace_job__ = None;
10040                while let Some(k) = map_.next_key()? {
10041                    match k {
10042                        GeneratedField::FragmentGraph => {
10043                            if fragment_graph__.is_some() {
10044                                return Err(serde::de::Error::duplicate_field("fragmentGraph"));
10045                            }
10046                            fragment_graph__ = map_.next_value()?;
10047                        }
10048                        GeneratedField::ReplaceTable => {
10049                            if replace_job__.is_some() {
10050                                return Err(serde::de::Error::duplicate_field("replaceTable"));
10051                            }
10052                            replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
10053;
10054                        }
10055                        GeneratedField::ReplaceSource => {
10056                            if replace_job__.is_some() {
10057                                return Err(serde::de::Error::duplicate_field("replaceSource"));
10058                            }
10059                            replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
10060;
10061                        }
10062                        GeneratedField::ReplaceMaterializedView => {
10063                            if replace_job__.is_some() {
10064                                return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
10065                            }
10066                            replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
10067;
10068                        }
10069                    }
10070                }
10071                Ok(ReplaceJobPlan {
10072                    fragment_graph: fragment_graph__,
10073                    replace_job: replace_job__,
10074                })
10075            }
10076        }
10077        deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
10078    }
10079}
10080impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
10081    #[allow(deprecated)]
10082    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10083    where
10084        S: serde::Serializer,
10085    {
10086        use serde::ser::SerializeStruct;
10087        let mut len = 0;
10088        if self.table.is_some() {
10089            len += 1;
10090        }
10091        let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
10092        if let Some(v) = self.table.as_ref() {
10093            struct_ser.serialize_field("table", v)?;
10094        }
10095        struct_ser.end()
10096    }
10097}
10098impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
10099    #[allow(deprecated)]
10100    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10101    where
10102        D: serde::Deserializer<'de>,
10103    {
10104        const FIELDS: &[&str] = &[
10105            "table",
10106        ];
10107
10108        #[allow(clippy::enum_variant_names)]
10109        enum GeneratedField {
10110            Table,
10111        }
10112        impl<'de> serde::Deserialize<'de> for GeneratedField {
10113            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10114            where
10115                D: serde::Deserializer<'de>,
10116            {
10117                struct GeneratedVisitor;
10118
10119                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10120                    type Value = GeneratedField;
10121
10122                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10123                        write!(formatter, "expected one of: {:?}", &FIELDS)
10124                    }
10125
10126                    #[allow(unused_variables)]
10127                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10128                    where
10129                        E: serde::de::Error,
10130                    {
10131                        match value {
10132                            "table" => Ok(GeneratedField::Table),
10133                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10134                        }
10135                    }
10136                }
10137                deserializer.deserialize_identifier(GeneratedVisitor)
10138            }
10139        }
10140        struct GeneratedVisitor;
10141        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10142            type Value = replace_job_plan::ReplaceMaterializedView;
10143
10144            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10145                formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
10146            }
10147
10148            fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
10149                where
10150                    V: serde::de::MapAccess<'de>,
10151            {
10152                let mut table__ = None;
10153                while let Some(k) = map_.next_key()? {
10154                    match k {
10155                        GeneratedField::Table => {
10156                            if table__.is_some() {
10157                                return Err(serde::de::Error::duplicate_field("table"));
10158                            }
10159                            table__ = map_.next_value()?;
10160                        }
10161                    }
10162                }
10163                Ok(replace_job_plan::ReplaceMaterializedView {
10164                    table: table__,
10165                })
10166            }
10167        }
10168        deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
10169    }
10170}
10171impl serde::Serialize for replace_job_plan::ReplaceSource {
10172    #[allow(deprecated)]
10173    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10174    where
10175        S: serde::Serializer,
10176    {
10177        use serde::ser::SerializeStruct;
10178        let mut len = 0;
10179        if self.source.is_some() {
10180            len += 1;
10181        }
10182        let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
10183        if let Some(v) = self.source.as_ref() {
10184            struct_ser.serialize_field("source", v)?;
10185        }
10186        struct_ser.end()
10187    }
10188}
10189impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
10190    #[allow(deprecated)]
10191    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10192    where
10193        D: serde::Deserializer<'de>,
10194    {
10195        const FIELDS: &[&str] = &[
10196            "source",
10197        ];
10198
10199        #[allow(clippy::enum_variant_names)]
10200        enum GeneratedField {
10201            Source,
10202        }
10203        impl<'de> serde::Deserialize<'de> for GeneratedField {
10204            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10205            where
10206                D: serde::Deserializer<'de>,
10207            {
10208                struct GeneratedVisitor;
10209
10210                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10211                    type Value = GeneratedField;
10212
10213                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10214                        write!(formatter, "expected one of: {:?}", &FIELDS)
10215                    }
10216
10217                    #[allow(unused_variables)]
10218                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10219                    where
10220                        E: serde::de::Error,
10221                    {
10222                        match value {
10223                            "source" => Ok(GeneratedField::Source),
10224                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10225                        }
10226                    }
10227                }
10228                deserializer.deserialize_identifier(GeneratedVisitor)
10229            }
10230        }
10231        struct GeneratedVisitor;
10232        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10233            type Value = replace_job_plan::ReplaceSource;
10234
10235            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10236                formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
10237            }
10238
10239            fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
10240                where
10241                    V: serde::de::MapAccess<'de>,
10242            {
10243                let mut source__ = None;
10244                while let Some(k) = map_.next_key()? {
10245                    match k {
10246                        GeneratedField::Source => {
10247                            if source__.is_some() {
10248                                return Err(serde::de::Error::duplicate_field("source"));
10249                            }
10250                            source__ = map_.next_value()?;
10251                        }
10252                    }
10253                }
10254                Ok(replace_job_plan::ReplaceSource {
10255                    source: source__,
10256                })
10257            }
10258        }
10259        deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
10260    }
10261}
10262impl serde::Serialize for replace_job_plan::ReplaceTable {
10263    #[allow(deprecated)]
10264    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10265    where
10266        S: serde::Serializer,
10267    {
10268        use serde::ser::SerializeStruct;
10269        let mut len = 0;
10270        if self.table.is_some() {
10271            len += 1;
10272        }
10273        if self.source.is_some() {
10274            len += 1;
10275        }
10276        if self.job_type != 0 {
10277            len += 1;
10278        }
10279        let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
10280        if let Some(v) = self.table.as_ref() {
10281            struct_ser.serialize_field("table", v)?;
10282        }
10283        if let Some(v) = self.source.as_ref() {
10284            struct_ser.serialize_field("source", v)?;
10285        }
10286        if self.job_type != 0 {
10287            let v = TableJobType::try_from(self.job_type)
10288                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
10289            struct_ser.serialize_field("jobType", &v)?;
10290        }
10291        struct_ser.end()
10292    }
10293}
10294impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
10295    #[allow(deprecated)]
10296    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10297    where
10298        D: serde::Deserializer<'de>,
10299    {
10300        const FIELDS: &[&str] = &[
10301            "table",
10302            "source",
10303            "job_type",
10304            "jobType",
10305        ];
10306
10307        #[allow(clippy::enum_variant_names)]
10308        enum GeneratedField {
10309            Table,
10310            Source,
10311            JobType,
10312        }
10313        impl<'de> serde::Deserialize<'de> for GeneratedField {
10314            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10315            where
10316                D: serde::Deserializer<'de>,
10317            {
10318                struct GeneratedVisitor;
10319
10320                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10321                    type Value = GeneratedField;
10322
10323                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10324                        write!(formatter, "expected one of: {:?}", &FIELDS)
10325                    }
10326
10327                    #[allow(unused_variables)]
10328                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10329                    where
10330                        E: serde::de::Error,
10331                    {
10332                        match value {
10333                            "table" => Ok(GeneratedField::Table),
10334                            "source" => Ok(GeneratedField::Source),
10335                            "jobType" | "job_type" => Ok(GeneratedField::JobType),
10336                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10337                        }
10338                    }
10339                }
10340                deserializer.deserialize_identifier(GeneratedVisitor)
10341            }
10342        }
10343        struct GeneratedVisitor;
10344        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10345            type Value = replace_job_plan::ReplaceTable;
10346
10347            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10348                formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
10349            }
10350
10351            fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
10352                where
10353                    V: serde::de::MapAccess<'de>,
10354            {
10355                let mut table__ = None;
10356                let mut source__ = None;
10357                let mut job_type__ = None;
10358                while let Some(k) = map_.next_key()? {
10359                    match k {
10360                        GeneratedField::Table => {
10361                            if table__.is_some() {
10362                                return Err(serde::de::Error::duplicate_field("table"));
10363                            }
10364                            table__ = map_.next_value()?;
10365                        }
10366                        GeneratedField::Source => {
10367                            if source__.is_some() {
10368                                return Err(serde::de::Error::duplicate_field("source"));
10369                            }
10370                            source__ = map_.next_value()?;
10371                        }
10372                        GeneratedField::JobType => {
10373                            if job_type__.is_some() {
10374                                return Err(serde::de::Error::duplicate_field("jobType"));
10375                            }
10376                            job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
10377                        }
10378                    }
10379                }
10380                Ok(replace_job_plan::ReplaceTable {
10381                    table: table__,
10382                    source: source__,
10383                    job_type: job_type__.unwrap_or_default(),
10384                })
10385            }
10386        }
10387        deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
10388    }
10389}
10390impl serde::Serialize for ReplaceJobPlanRequest {
10391    #[allow(deprecated)]
10392    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10393    where
10394        S: serde::Serializer,
10395    {
10396        use serde::ser::SerializeStruct;
10397        let mut len = 0;
10398        if self.plan.is_some() {
10399            len += 1;
10400        }
10401        let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
10402        if let Some(v) = self.plan.as_ref() {
10403            struct_ser.serialize_field("plan", v)?;
10404        }
10405        struct_ser.end()
10406    }
10407}
10408impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
10409    #[allow(deprecated)]
10410    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10411    where
10412        D: serde::Deserializer<'de>,
10413    {
10414        const FIELDS: &[&str] = &[
10415            "plan",
10416        ];
10417
10418        #[allow(clippy::enum_variant_names)]
10419        enum GeneratedField {
10420            Plan,
10421        }
10422        impl<'de> serde::Deserialize<'de> for GeneratedField {
10423            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10424            where
10425                D: serde::Deserializer<'de>,
10426            {
10427                struct GeneratedVisitor;
10428
10429                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10430                    type Value = GeneratedField;
10431
10432                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10433                        write!(formatter, "expected one of: {:?}", &FIELDS)
10434                    }
10435
10436                    #[allow(unused_variables)]
10437                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10438                    where
10439                        E: serde::de::Error,
10440                    {
10441                        match value {
10442                            "plan" => Ok(GeneratedField::Plan),
10443                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10444                        }
10445                    }
10446                }
10447                deserializer.deserialize_identifier(GeneratedVisitor)
10448            }
10449        }
10450        struct GeneratedVisitor;
10451        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10452            type Value = ReplaceJobPlanRequest;
10453
10454            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10455                formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
10456            }
10457
10458            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
10459                where
10460                    V: serde::de::MapAccess<'de>,
10461            {
10462                let mut plan__ = None;
10463                while let Some(k) = map_.next_key()? {
10464                    match k {
10465                        GeneratedField::Plan => {
10466                            if plan__.is_some() {
10467                                return Err(serde::de::Error::duplicate_field("plan"));
10468                            }
10469                            plan__ = map_.next_value()?;
10470                        }
10471                    }
10472                }
10473                Ok(ReplaceJobPlanRequest {
10474                    plan: plan__,
10475                })
10476            }
10477        }
10478        deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
10479    }
10480}
10481impl serde::Serialize for ReplaceJobPlanResponse {
10482    #[allow(deprecated)]
10483    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10484    where
10485        S: serde::Serializer,
10486    {
10487        use serde::ser::SerializeStruct;
10488        let mut len = 0;
10489        if self.status.is_some() {
10490            len += 1;
10491        }
10492        if self.version.is_some() {
10493            len += 1;
10494        }
10495        let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
10496        if let Some(v) = self.status.as_ref() {
10497            struct_ser.serialize_field("status", v)?;
10498        }
10499        if let Some(v) = self.version.as_ref() {
10500            struct_ser.serialize_field("version", v)?;
10501        }
10502        struct_ser.end()
10503    }
10504}
10505impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
10506    #[allow(deprecated)]
10507    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10508    where
10509        D: serde::Deserializer<'de>,
10510    {
10511        const FIELDS: &[&str] = &[
10512            "status",
10513            "version",
10514        ];
10515
10516        #[allow(clippy::enum_variant_names)]
10517        enum GeneratedField {
10518            Status,
10519            Version,
10520        }
10521        impl<'de> serde::Deserialize<'de> for GeneratedField {
10522            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10523            where
10524                D: serde::Deserializer<'de>,
10525            {
10526                struct GeneratedVisitor;
10527
10528                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10529                    type Value = GeneratedField;
10530
10531                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10532                        write!(formatter, "expected one of: {:?}", &FIELDS)
10533                    }
10534
10535                    #[allow(unused_variables)]
10536                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10537                    where
10538                        E: serde::de::Error,
10539                    {
10540                        match value {
10541                            "status" => Ok(GeneratedField::Status),
10542                            "version" => Ok(GeneratedField::Version),
10543                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10544                        }
10545                    }
10546                }
10547                deserializer.deserialize_identifier(GeneratedVisitor)
10548            }
10549        }
10550        struct GeneratedVisitor;
10551        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10552            type Value = ReplaceJobPlanResponse;
10553
10554            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10555                formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
10556            }
10557
10558            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
10559                where
10560                    V: serde::de::MapAccess<'de>,
10561            {
10562                let mut status__ = None;
10563                let mut version__ = None;
10564                while let Some(k) = map_.next_key()? {
10565                    match k {
10566                        GeneratedField::Status => {
10567                            if status__.is_some() {
10568                                return Err(serde::de::Error::duplicate_field("status"));
10569                            }
10570                            status__ = map_.next_value()?;
10571                        }
10572                        GeneratedField::Version => {
10573                            if version__.is_some() {
10574                                return Err(serde::de::Error::duplicate_field("version"));
10575                            }
10576                            version__ = map_.next_value()?;
10577                        }
10578                    }
10579                }
10580                Ok(ReplaceJobPlanResponse {
10581                    status: status__,
10582                    version: version__,
10583                })
10584            }
10585        }
10586        deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
10587    }
10588}
10589impl serde::Serialize for RisectlListStateTablesRequest {
10590    #[allow(deprecated)]
10591    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10592    where
10593        S: serde::Serializer,
10594    {
10595        use serde::ser::SerializeStruct;
10596        let len = 0;
10597        let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
10598        struct_ser.end()
10599    }
10600}
10601impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
10602    #[allow(deprecated)]
10603    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10604    where
10605        D: serde::Deserializer<'de>,
10606    {
10607        const FIELDS: &[&str] = &[
10608        ];
10609
10610        #[allow(clippy::enum_variant_names)]
10611        enum GeneratedField {
10612        }
10613        impl<'de> serde::Deserialize<'de> for GeneratedField {
10614            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10615            where
10616                D: serde::Deserializer<'de>,
10617            {
10618                struct GeneratedVisitor;
10619
10620                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10621                    type Value = GeneratedField;
10622
10623                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10624                        write!(formatter, "expected one of: {:?}", &FIELDS)
10625                    }
10626
10627                    #[allow(unused_variables)]
10628                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10629                    where
10630                        E: serde::de::Error,
10631                    {
10632                            Err(serde::de::Error::unknown_field(value, FIELDS))
10633                    }
10634                }
10635                deserializer.deserialize_identifier(GeneratedVisitor)
10636            }
10637        }
10638        struct GeneratedVisitor;
10639        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10640            type Value = RisectlListStateTablesRequest;
10641
10642            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10643                formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
10644            }
10645
10646            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
10647                where
10648                    V: serde::de::MapAccess<'de>,
10649            {
10650                while map_.next_key::<GeneratedField>()?.is_some() {
10651                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10652                }
10653                Ok(RisectlListStateTablesRequest {
10654                })
10655            }
10656        }
10657        deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
10658    }
10659}
10660impl serde::Serialize for RisectlListStateTablesResponse {
10661    #[allow(deprecated)]
10662    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10663    where
10664        S: serde::Serializer,
10665    {
10666        use serde::ser::SerializeStruct;
10667        let mut len = 0;
10668        if !self.tables.is_empty() {
10669            len += 1;
10670        }
10671        let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
10672        if !self.tables.is_empty() {
10673            struct_ser.serialize_field("tables", &self.tables)?;
10674        }
10675        struct_ser.end()
10676    }
10677}
10678impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
10679    #[allow(deprecated)]
10680    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10681    where
10682        D: serde::Deserializer<'de>,
10683    {
10684        const FIELDS: &[&str] = &[
10685            "tables",
10686        ];
10687
10688        #[allow(clippy::enum_variant_names)]
10689        enum GeneratedField {
10690            Tables,
10691        }
10692        impl<'de> serde::Deserialize<'de> for GeneratedField {
10693            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10694            where
10695                D: serde::Deserializer<'de>,
10696            {
10697                struct GeneratedVisitor;
10698
10699                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10700                    type Value = GeneratedField;
10701
10702                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10703                        write!(formatter, "expected one of: {:?}", &FIELDS)
10704                    }
10705
10706                    #[allow(unused_variables)]
10707                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10708                    where
10709                        E: serde::de::Error,
10710                    {
10711                        match value {
10712                            "tables" => Ok(GeneratedField::Tables),
10713                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10714                        }
10715                    }
10716                }
10717                deserializer.deserialize_identifier(GeneratedVisitor)
10718            }
10719        }
10720        struct GeneratedVisitor;
10721        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10722            type Value = RisectlListStateTablesResponse;
10723
10724            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10725                formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
10726            }
10727
10728            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
10729                where
10730                    V: serde::de::MapAccess<'de>,
10731            {
10732                let mut tables__ = None;
10733                while let Some(k) = map_.next_key()? {
10734                    match k {
10735                        GeneratedField::Tables => {
10736                            if tables__.is_some() {
10737                                return Err(serde::de::Error::duplicate_field("tables"));
10738                            }
10739                            tables__ = Some(map_.next_value()?);
10740                        }
10741                    }
10742                }
10743                Ok(RisectlListStateTablesResponse {
10744                    tables: tables__.unwrap_or_default(),
10745                })
10746            }
10747        }
10748        deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
10749    }
10750}
10751impl serde::Serialize for SchemaChangeEnvelope {
10752    #[allow(deprecated)]
10753    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10754    where
10755        S: serde::Serializer,
10756    {
10757        use serde::ser::SerializeStruct;
10758        let mut len = 0;
10759        if !self.table_changes.is_empty() {
10760            len += 1;
10761        }
10762        let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
10763        if !self.table_changes.is_empty() {
10764            struct_ser.serialize_field("tableChanges", &self.table_changes)?;
10765        }
10766        struct_ser.end()
10767    }
10768}
10769impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
10770    #[allow(deprecated)]
10771    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10772    where
10773        D: serde::Deserializer<'de>,
10774    {
10775        const FIELDS: &[&str] = &[
10776            "table_changes",
10777            "tableChanges",
10778        ];
10779
10780        #[allow(clippy::enum_variant_names)]
10781        enum GeneratedField {
10782            TableChanges,
10783        }
10784        impl<'de> serde::Deserialize<'de> for GeneratedField {
10785            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10786            where
10787                D: serde::Deserializer<'de>,
10788            {
10789                struct GeneratedVisitor;
10790
10791                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10792                    type Value = GeneratedField;
10793
10794                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10795                        write!(formatter, "expected one of: {:?}", &FIELDS)
10796                    }
10797
10798                    #[allow(unused_variables)]
10799                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10800                    where
10801                        E: serde::de::Error,
10802                    {
10803                        match value {
10804                            "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
10805                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10806                        }
10807                    }
10808                }
10809                deserializer.deserialize_identifier(GeneratedVisitor)
10810            }
10811        }
10812        struct GeneratedVisitor;
10813        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10814            type Value = SchemaChangeEnvelope;
10815
10816            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10817                formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
10818            }
10819
10820            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
10821                where
10822                    V: serde::de::MapAccess<'de>,
10823            {
10824                let mut table_changes__ = None;
10825                while let Some(k) = map_.next_key()? {
10826                    match k {
10827                        GeneratedField::TableChanges => {
10828                            if table_changes__.is_some() {
10829                                return Err(serde::de::Error::duplicate_field("tableChanges"));
10830                            }
10831                            table_changes__ = Some(map_.next_value()?);
10832                        }
10833                    }
10834                }
10835                Ok(SchemaChangeEnvelope {
10836                    table_changes: table_changes__.unwrap_or_default(),
10837                })
10838            }
10839        }
10840        deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
10841    }
10842}
10843impl serde::Serialize for TableJobType {
10844    #[allow(deprecated)]
10845    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10846    where
10847        S: serde::Serializer,
10848    {
10849        let variant = match self {
10850            Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
10851            Self::General => "TABLE_JOB_TYPE_GENERAL",
10852            Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
10853        };
10854        serializer.serialize_str(variant)
10855    }
10856}
10857impl<'de> serde::Deserialize<'de> for TableJobType {
10858    #[allow(deprecated)]
10859    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10860    where
10861        D: serde::Deserializer<'de>,
10862    {
10863        const FIELDS: &[&str] = &[
10864            "TABLE_JOB_TYPE_UNSPECIFIED",
10865            "TABLE_JOB_TYPE_GENERAL",
10866            "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
10867        ];
10868
10869        struct GeneratedVisitor;
10870
10871        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10872            type Value = TableJobType;
10873
10874            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10875                write!(formatter, "expected one of: {:?}", &FIELDS)
10876            }
10877
10878            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10879            where
10880                E: serde::de::Error,
10881            {
10882                i32::try_from(v)
10883                    .ok()
10884                    .and_then(|x| x.try_into().ok())
10885                    .ok_or_else(|| {
10886                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10887                    })
10888            }
10889
10890            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10891            where
10892                E: serde::de::Error,
10893            {
10894                i32::try_from(v)
10895                    .ok()
10896                    .and_then(|x| x.try_into().ok())
10897                    .ok_or_else(|| {
10898                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10899                    })
10900            }
10901
10902            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10903            where
10904                E: serde::de::Error,
10905            {
10906                match value {
10907                    "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
10908                    "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
10909                    "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
10910                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10911                }
10912            }
10913        }
10914        deserializer.deserialize_any(GeneratedVisitor)
10915    }
10916}
10917impl serde::Serialize for TableSchemaChange {
10918    #[allow(deprecated)]
10919    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10920    where
10921        S: serde::Serializer,
10922    {
10923        use serde::ser::SerializeStruct;
10924        let mut len = 0;
10925        if self.change_type != 0 {
10926            len += 1;
10927        }
10928        if !self.cdc_table_id.is_empty() {
10929            len += 1;
10930        }
10931        if !self.columns.is_empty() {
10932            len += 1;
10933        }
10934        if !self.upstream_ddl.is_empty() {
10935            len += 1;
10936        }
10937        let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
10938        if self.change_type != 0 {
10939            let v = table_schema_change::TableChangeType::try_from(self.change_type)
10940                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
10941            struct_ser.serialize_field("changeType", &v)?;
10942        }
10943        if !self.cdc_table_id.is_empty() {
10944            struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
10945        }
10946        if !self.columns.is_empty() {
10947            struct_ser.serialize_field("columns", &self.columns)?;
10948        }
10949        if !self.upstream_ddl.is_empty() {
10950            struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
10951        }
10952        struct_ser.end()
10953    }
10954}
10955impl<'de> serde::Deserialize<'de> for TableSchemaChange {
10956    #[allow(deprecated)]
10957    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10958    where
10959        D: serde::Deserializer<'de>,
10960    {
10961        const FIELDS: &[&str] = &[
10962            "change_type",
10963            "changeType",
10964            "cdc_table_id",
10965            "cdcTableId",
10966            "columns",
10967            "upstream_ddl",
10968            "upstreamDdl",
10969        ];
10970
10971        #[allow(clippy::enum_variant_names)]
10972        enum GeneratedField {
10973            ChangeType,
10974            CdcTableId,
10975            Columns,
10976            UpstreamDdl,
10977        }
10978        impl<'de> serde::Deserialize<'de> for GeneratedField {
10979            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10980            where
10981                D: serde::Deserializer<'de>,
10982            {
10983                struct GeneratedVisitor;
10984
10985                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10986                    type Value = GeneratedField;
10987
10988                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10989                        write!(formatter, "expected one of: {:?}", &FIELDS)
10990                    }
10991
10992                    #[allow(unused_variables)]
10993                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10994                    where
10995                        E: serde::de::Error,
10996                    {
10997                        match value {
10998                            "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
10999                            "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
11000                            "columns" => Ok(GeneratedField::Columns),
11001                            "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
11002                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11003                        }
11004                    }
11005                }
11006                deserializer.deserialize_identifier(GeneratedVisitor)
11007            }
11008        }
11009        struct GeneratedVisitor;
11010        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11011            type Value = TableSchemaChange;
11012
11013            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11014                formatter.write_str("struct ddl_service.TableSchemaChange")
11015            }
11016
11017            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
11018                where
11019                    V: serde::de::MapAccess<'de>,
11020            {
11021                let mut change_type__ = None;
11022                let mut cdc_table_id__ = None;
11023                let mut columns__ = None;
11024                let mut upstream_ddl__ = None;
11025                while let Some(k) = map_.next_key()? {
11026                    match k {
11027                        GeneratedField::ChangeType => {
11028                            if change_type__.is_some() {
11029                                return Err(serde::de::Error::duplicate_field("changeType"));
11030                            }
11031                            change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
11032                        }
11033                        GeneratedField::CdcTableId => {
11034                            if cdc_table_id__.is_some() {
11035                                return Err(serde::de::Error::duplicate_field("cdcTableId"));
11036                            }
11037                            cdc_table_id__ = Some(map_.next_value()?);
11038                        }
11039                        GeneratedField::Columns => {
11040                            if columns__.is_some() {
11041                                return Err(serde::de::Error::duplicate_field("columns"));
11042                            }
11043                            columns__ = Some(map_.next_value()?);
11044                        }
11045                        GeneratedField::UpstreamDdl => {
11046                            if upstream_ddl__.is_some() {
11047                                return Err(serde::de::Error::duplicate_field("upstreamDdl"));
11048                            }
11049                            upstream_ddl__ = Some(map_.next_value()?);
11050                        }
11051                    }
11052                }
11053                Ok(TableSchemaChange {
11054                    change_type: change_type__.unwrap_or_default(),
11055                    cdc_table_id: cdc_table_id__.unwrap_or_default(),
11056                    columns: columns__.unwrap_or_default(),
11057                    upstream_ddl: upstream_ddl__.unwrap_or_default(),
11058                })
11059            }
11060        }
11061        deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
11062    }
11063}
11064impl serde::Serialize for table_schema_change::TableChangeType {
11065    #[allow(deprecated)]
11066    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11067    where
11068        S: serde::Serializer,
11069    {
11070        let variant = match self {
11071            Self::Unspecified => "UNSPECIFIED",
11072            Self::Alter => "ALTER",
11073            Self::Create => "CREATE",
11074            Self::Drop => "DROP",
11075        };
11076        serializer.serialize_str(variant)
11077    }
11078}
11079impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
11080    #[allow(deprecated)]
11081    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11082    where
11083        D: serde::Deserializer<'de>,
11084    {
11085        const FIELDS: &[&str] = &[
11086            "UNSPECIFIED",
11087            "ALTER",
11088            "CREATE",
11089            "DROP",
11090        ];
11091
11092        struct GeneratedVisitor;
11093
11094        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11095            type Value = table_schema_change::TableChangeType;
11096
11097            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11098                write!(formatter, "expected one of: {:?}", &FIELDS)
11099            }
11100
11101            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11102            where
11103                E: serde::de::Error,
11104            {
11105                i32::try_from(v)
11106                    .ok()
11107                    .and_then(|x| x.try_into().ok())
11108                    .ok_or_else(|| {
11109                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11110                    })
11111            }
11112
11113            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11114            where
11115                E: serde::de::Error,
11116            {
11117                i32::try_from(v)
11118                    .ok()
11119                    .and_then(|x| x.try_into().ok())
11120                    .ok_or_else(|| {
11121                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11122                    })
11123            }
11124
11125            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11126            where
11127                E: serde::de::Error,
11128            {
11129                match value {
11130                    "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
11131                    "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
11132                    "CREATE" => Ok(table_schema_change::TableChangeType::Create),
11133                    "DROP" => Ok(table_schema_change::TableChangeType::Drop),
11134                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11135                }
11136            }
11137        }
11138        deserializer.deserialize_any(GeneratedVisitor)
11139    }
11140}
11141impl serde::Serialize for WaitRequest {
11142    #[allow(deprecated)]
11143    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11144    where
11145        S: serde::Serializer,
11146    {
11147        use serde::ser::SerializeStruct;
11148        let len = 0;
11149        let struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
11150        struct_ser.end()
11151    }
11152}
11153impl<'de> serde::Deserialize<'de> for WaitRequest {
11154    #[allow(deprecated)]
11155    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11156    where
11157        D: serde::Deserializer<'de>,
11158    {
11159        const FIELDS: &[&str] = &[
11160        ];
11161
11162        #[allow(clippy::enum_variant_names)]
11163        enum GeneratedField {
11164        }
11165        impl<'de> serde::Deserialize<'de> for GeneratedField {
11166            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11167            where
11168                D: serde::Deserializer<'de>,
11169            {
11170                struct GeneratedVisitor;
11171
11172                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11173                    type Value = GeneratedField;
11174
11175                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11176                        write!(formatter, "expected one of: {:?}", &FIELDS)
11177                    }
11178
11179                    #[allow(unused_variables)]
11180                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11181                    where
11182                        E: serde::de::Error,
11183                    {
11184                            Err(serde::de::Error::unknown_field(value, FIELDS))
11185                    }
11186                }
11187                deserializer.deserialize_identifier(GeneratedVisitor)
11188            }
11189        }
11190        struct GeneratedVisitor;
11191        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11192            type Value = WaitRequest;
11193
11194            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11195                formatter.write_str("struct ddl_service.WaitRequest")
11196            }
11197
11198            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
11199                where
11200                    V: serde::de::MapAccess<'de>,
11201            {
11202                while map_.next_key::<GeneratedField>()?.is_some() {
11203                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11204                }
11205                Ok(WaitRequest {
11206                })
11207            }
11208        }
11209        deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
11210    }
11211}
11212impl serde::Serialize for WaitResponse {
11213    #[allow(deprecated)]
11214    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11215    where
11216        S: serde::Serializer,
11217    {
11218        use serde::ser::SerializeStruct;
11219        let len = 0;
11220        let struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
11221        struct_ser.end()
11222    }
11223}
11224impl<'de> serde::Deserialize<'de> for WaitResponse {
11225    #[allow(deprecated)]
11226    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11227    where
11228        D: serde::Deserializer<'de>,
11229    {
11230        const FIELDS: &[&str] = &[
11231        ];
11232
11233        #[allow(clippy::enum_variant_names)]
11234        enum GeneratedField {
11235        }
11236        impl<'de> serde::Deserialize<'de> for GeneratedField {
11237            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11238            where
11239                D: serde::Deserializer<'de>,
11240            {
11241                struct GeneratedVisitor;
11242
11243                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11244                    type Value = GeneratedField;
11245
11246                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11247                        write!(formatter, "expected one of: {:?}", &FIELDS)
11248                    }
11249
11250                    #[allow(unused_variables)]
11251                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11252                    where
11253                        E: serde::de::Error,
11254                    {
11255                            Err(serde::de::Error::unknown_field(value, FIELDS))
11256                    }
11257                }
11258                deserializer.deserialize_identifier(GeneratedVisitor)
11259            }
11260        }
11261        struct GeneratedVisitor;
11262        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11263            type Value = WaitResponse;
11264
11265            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11266                formatter.write_str("struct ddl_service.WaitResponse")
11267            }
11268
11269            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
11270                where
11271                    V: serde::de::MapAccess<'de>,
11272            {
11273                while map_.next_key::<GeneratedField>()?.is_some() {
11274                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11275                }
11276                Ok(WaitResponse {
11277                })
11278            }
11279        }
11280        deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
11281    }
11282}
11283impl serde::Serialize for WaitVersion {
11284    #[allow(deprecated)]
11285    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11286    where
11287        S: serde::Serializer,
11288    {
11289        use serde::ser::SerializeStruct;
11290        let mut len = 0;
11291        if self.catalog_version != 0 {
11292            len += 1;
11293        }
11294        if self.hummock_version_id != 0 {
11295            len += 1;
11296        }
11297        let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
11298        if self.catalog_version != 0 {
11299            #[allow(clippy::needless_borrow)]
11300            #[allow(clippy::needless_borrows_for_generic_args)]
11301            struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11302        }
11303        if self.hummock_version_id != 0 {
11304            #[allow(clippy::needless_borrow)]
11305            #[allow(clippy::needless_borrows_for_generic_args)]
11306            struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
11307        }
11308        struct_ser.end()
11309    }
11310}
11311impl<'de> serde::Deserialize<'de> for WaitVersion {
11312    #[allow(deprecated)]
11313    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11314    where
11315        D: serde::Deserializer<'de>,
11316    {
11317        const FIELDS: &[&str] = &[
11318            "catalog_version",
11319            "catalogVersion",
11320            "hummock_version_id",
11321            "hummockVersionId",
11322        ];
11323
11324        #[allow(clippy::enum_variant_names)]
11325        enum GeneratedField {
11326            CatalogVersion,
11327            HummockVersionId,
11328        }
11329        impl<'de> serde::Deserialize<'de> for GeneratedField {
11330            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11331            where
11332                D: serde::Deserializer<'de>,
11333            {
11334                struct GeneratedVisitor;
11335
11336                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11337                    type Value = GeneratedField;
11338
11339                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11340                        write!(formatter, "expected one of: {:?}", &FIELDS)
11341                    }
11342
11343                    #[allow(unused_variables)]
11344                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11345                    where
11346                        E: serde::de::Error,
11347                    {
11348                        match value {
11349                            "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
11350                            "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
11351                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11352                        }
11353                    }
11354                }
11355                deserializer.deserialize_identifier(GeneratedVisitor)
11356            }
11357        }
11358        struct GeneratedVisitor;
11359        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11360            type Value = WaitVersion;
11361
11362            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11363                formatter.write_str("struct ddl_service.WaitVersion")
11364            }
11365
11366            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
11367                where
11368                    V: serde::de::MapAccess<'de>,
11369            {
11370                let mut catalog_version__ = None;
11371                let mut hummock_version_id__ = None;
11372                while let Some(k) = map_.next_key()? {
11373                    match k {
11374                        GeneratedField::CatalogVersion => {
11375                            if catalog_version__.is_some() {
11376                                return Err(serde::de::Error::duplicate_field("catalogVersion"));
11377                            }
11378                            catalog_version__ = 
11379                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11380                            ;
11381                        }
11382                        GeneratedField::HummockVersionId => {
11383                            if hummock_version_id__.is_some() {
11384                                return Err(serde::de::Error::duplicate_field("hummockVersionId"));
11385                            }
11386                            hummock_version_id__ = 
11387                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11388                            ;
11389                        }
11390                    }
11391                }
11392                Ok(WaitVersion {
11393                    catalog_version: catalog_version__.unwrap_or_default(),
11394                    hummock_version_id: hummock_version_id__.unwrap_or_default(),
11395                })
11396            }
11397        }
11398        deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
11399    }
11400}