risingwave_pb/
catalog.serde.rs

1use crate::catalog::*;
2impl serde::Serialize for ColIndexMapping {
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.target_size != 0 {
11            len += 1;
12        }
13        if !self.map.is_empty() {
14            len += 1;
15        }
16        let mut struct_ser = serializer.serialize_struct("catalog.ColIndexMapping", len)?;
17        if self.target_size != 0 {
18            #[allow(clippy::needless_borrow)]
19            #[allow(clippy::needless_borrows_for_generic_args)]
20            struct_ser.serialize_field("targetSize", ToString::to_string(&self.target_size).as_str())?;
21        }
22        if !self.map.is_empty() {
23            struct_ser.serialize_field("map", &self.map.iter().map(ToString::to_string).collect::<Vec<_>>())?;
24        }
25        struct_ser.end()
26    }
27}
28impl<'de> serde::Deserialize<'de> for ColIndexMapping {
29    #[allow(deprecated)]
30    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31    where
32        D: serde::Deserializer<'de>,
33    {
34        const FIELDS: &[&str] = &[
35            "target_size",
36            "targetSize",
37            "map",
38        ];
39
40        #[allow(clippy::enum_variant_names)]
41        enum GeneratedField {
42            TargetSize,
43            Map,
44        }
45        impl<'de> serde::Deserialize<'de> for GeneratedField {
46            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47            where
48                D: serde::Deserializer<'de>,
49            {
50                struct GeneratedVisitor;
51
52                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
53                    type Value = GeneratedField;
54
55                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56                        write!(formatter, "expected one of: {:?}", &FIELDS)
57                    }
58
59                    #[allow(unused_variables)]
60                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61                    where
62                        E: serde::de::Error,
63                    {
64                        match value {
65                            "targetSize" | "target_size" => Ok(GeneratedField::TargetSize),
66                            "map" => Ok(GeneratedField::Map),
67                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68                        }
69                    }
70                }
71                deserializer.deserialize_identifier(GeneratedVisitor)
72            }
73        }
74        struct GeneratedVisitor;
75        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76            type Value = ColIndexMapping;
77
78            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79                formatter.write_str("struct catalog.ColIndexMapping")
80            }
81
82            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ColIndexMapping, V::Error>
83                where
84                    V: serde::de::MapAccess<'de>,
85            {
86                let mut target_size__ = None;
87                let mut map__ = None;
88                while let Some(k) = map_.next_key()? {
89                    match k {
90                        GeneratedField::TargetSize => {
91                            if target_size__.is_some() {
92                                return Err(serde::de::Error::duplicate_field("targetSize"));
93                            }
94                            target_size__ = 
95                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
96                            ;
97                        }
98                        GeneratedField::Map => {
99                            if map__.is_some() {
100                                return Err(serde::de::Error::duplicate_field("map"));
101                            }
102                            map__ = 
103                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
104                                    .into_iter().map(|x| x.0).collect())
105                            ;
106                        }
107                    }
108                }
109                Ok(ColIndexMapping {
110                    target_size: target_size__.unwrap_or_default(),
111                    map: map__.unwrap_or_default(),
112                })
113            }
114        }
115        deserializer.deserialize_struct("catalog.ColIndexMapping", FIELDS, GeneratedVisitor)
116    }
117}
118impl serde::Serialize for Comment {
119    #[allow(deprecated)]
120    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
121    where
122        S: serde::Serializer,
123    {
124        use serde::ser::SerializeStruct;
125        let mut len = 0;
126        if self.table_id != 0 {
127            len += 1;
128        }
129        if self.schema_id != 0 {
130            len += 1;
131        }
132        if self.database_id != 0 {
133            len += 1;
134        }
135        if self.column_index.is_some() {
136            len += 1;
137        }
138        if self.description.is_some() {
139            len += 1;
140        }
141        let mut struct_ser = serializer.serialize_struct("catalog.Comment", len)?;
142        if self.table_id != 0 {
143            struct_ser.serialize_field("tableId", &self.table_id)?;
144        }
145        if self.schema_id != 0 {
146            struct_ser.serialize_field("schemaId", &self.schema_id)?;
147        }
148        if self.database_id != 0 {
149            struct_ser.serialize_field("databaseId", &self.database_id)?;
150        }
151        if let Some(v) = self.column_index.as_ref() {
152            struct_ser.serialize_field("columnIndex", v)?;
153        }
154        if let Some(v) = self.description.as_ref() {
155            struct_ser.serialize_field("description", v)?;
156        }
157        struct_ser.end()
158    }
159}
160impl<'de> serde::Deserialize<'de> for Comment {
161    #[allow(deprecated)]
162    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
163    where
164        D: serde::Deserializer<'de>,
165    {
166        const FIELDS: &[&str] = &[
167            "table_id",
168            "tableId",
169            "schema_id",
170            "schemaId",
171            "database_id",
172            "databaseId",
173            "column_index",
174            "columnIndex",
175            "description",
176        ];
177
178        #[allow(clippy::enum_variant_names)]
179        enum GeneratedField {
180            TableId,
181            SchemaId,
182            DatabaseId,
183            ColumnIndex,
184            Description,
185        }
186        impl<'de> serde::Deserialize<'de> for GeneratedField {
187            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
188            where
189                D: serde::Deserializer<'de>,
190            {
191                struct GeneratedVisitor;
192
193                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
194                    type Value = GeneratedField;
195
196                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
197                        write!(formatter, "expected one of: {:?}", &FIELDS)
198                    }
199
200                    #[allow(unused_variables)]
201                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
202                    where
203                        E: serde::de::Error,
204                    {
205                        match value {
206                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
207                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
208                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
209                            "columnIndex" | "column_index" => Ok(GeneratedField::ColumnIndex),
210                            "description" => Ok(GeneratedField::Description),
211                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
212                        }
213                    }
214                }
215                deserializer.deserialize_identifier(GeneratedVisitor)
216            }
217        }
218        struct GeneratedVisitor;
219        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
220            type Value = Comment;
221
222            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
223                formatter.write_str("struct catalog.Comment")
224            }
225
226            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Comment, V::Error>
227                where
228                    V: serde::de::MapAccess<'de>,
229            {
230                let mut table_id__ = None;
231                let mut schema_id__ = None;
232                let mut database_id__ = None;
233                let mut column_index__ = None;
234                let mut description__ = None;
235                while let Some(k) = map_.next_key()? {
236                    match k {
237                        GeneratedField::TableId => {
238                            if table_id__.is_some() {
239                                return Err(serde::de::Error::duplicate_field("tableId"));
240                            }
241                            table_id__ = 
242                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
243                            ;
244                        }
245                        GeneratedField::SchemaId => {
246                            if schema_id__.is_some() {
247                                return Err(serde::de::Error::duplicate_field("schemaId"));
248                            }
249                            schema_id__ = 
250                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
251                            ;
252                        }
253                        GeneratedField::DatabaseId => {
254                            if database_id__.is_some() {
255                                return Err(serde::de::Error::duplicate_field("databaseId"));
256                            }
257                            database_id__ = 
258                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
259                            ;
260                        }
261                        GeneratedField::ColumnIndex => {
262                            if column_index__.is_some() {
263                                return Err(serde::de::Error::duplicate_field("columnIndex"));
264                            }
265                            column_index__ = 
266                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
267                            ;
268                        }
269                        GeneratedField::Description => {
270                            if description__.is_some() {
271                                return Err(serde::de::Error::duplicate_field("description"));
272                            }
273                            description__ = map_.next_value()?;
274                        }
275                    }
276                }
277                Ok(Comment {
278                    table_id: table_id__.unwrap_or_default(),
279                    schema_id: schema_id__.unwrap_or_default(),
280                    database_id: database_id__.unwrap_or_default(),
281                    column_index: column_index__,
282                    description: description__,
283                })
284            }
285        }
286        deserializer.deserialize_struct("catalog.Comment", FIELDS, GeneratedVisitor)
287    }
288}
289impl serde::Serialize for Connection {
290    #[allow(deprecated)]
291    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
292    where
293        S: serde::Serializer,
294    {
295        use serde::ser::SerializeStruct;
296        let mut len = 0;
297        if self.id != 0 {
298            len += 1;
299        }
300        if self.schema_id != 0 {
301            len += 1;
302        }
303        if self.database_id != 0 {
304            len += 1;
305        }
306        if !self.name.is_empty() {
307            len += 1;
308        }
309        if self.owner != 0 {
310            len += 1;
311        }
312        if self.info.is_some() {
313            len += 1;
314        }
315        let mut struct_ser = serializer.serialize_struct("catalog.Connection", len)?;
316        if self.id != 0 {
317            struct_ser.serialize_field("id", &self.id)?;
318        }
319        if self.schema_id != 0 {
320            struct_ser.serialize_field("schemaId", &self.schema_id)?;
321        }
322        if self.database_id != 0 {
323            struct_ser.serialize_field("databaseId", &self.database_id)?;
324        }
325        if !self.name.is_empty() {
326            struct_ser.serialize_field("name", &self.name)?;
327        }
328        if self.owner != 0 {
329            struct_ser.serialize_field("owner", &self.owner)?;
330        }
331        if let Some(v) = self.info.as_ref() {
332            match v {
333                connection::Info::PrivateLinkService(v) => {
334                    struct_ser.serialize_field("privateLinkService", v)?;
335                }
336                connection::Info::ConnectionParams(v) => {
337                    struct_ser.serialize_field("connectionParams", v)?;
338                }
339            }
340        }
341        struct_ser.end()
342    }
343}
344impl<'de> serde::Deserialize<'de> for Connection {
345    #[allow(deprecated)]
346    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
347    where
348        D: serde::Deserializer<'de>,
349    {
350        const FIELDS: &[&str] = &[
351            "id",
352            "schema_id",
353            "schemaId",
354            "database_id",
355            "databaseId",
356            "name",
357            "owner",
358            "private_link_service",
359            "privateLinkService",
360            "connection_params",
361            "connectionParams",
362        ];
363
364        #[allow(clippy::enum_variant_names)]
365        enum GeneratedField {
366            Id,
367            SchemaId,
368            DatabaseId,
369            Name,
370            Owner,
371            PrivateLinkService,
372            ConnectionParams,
373        }
374        impl<'de> serde::Deserialize<'de> for GeneratedField {
375            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
376            where
377                D: serde::Deserializer<'de>,
378            {
379                struct GeneratedVisitor;
380
381                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
382                    type Value = GeneratedField;
383
384                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
385                        write!(formatter, "expected one of: {:?}", &FIELDS)
386                    }
387
388                    #[allow(unused_variables)]
389                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
390                    where
391                        E: serde::de::Error,
392                    {
393                        match value {
394                            "id" => Ok(GeneratedField::Id),
395                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
396                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
397                            "name" => Ok(GeneratedField::Name),
398                            "owner" => Ok(GeneratedField::Owner),
399                            "privateLinkService" | "private_link_service" => Ok(GeneratedField::PrivateLinkService),
400                            "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
401                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
402                        }
403                    }
404                }
405                deserializer.deserialize_identifier(GeneratedVisitor)
406            }
407        }
408        struct GeneratedVisitor;
409        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
410            type Value = Connection;
411
412            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
413                formatter.write_str("struct catalog.Connection")
414            }
415
416            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Connection, V::Error>
417                where
418                    V: serde::de::MapAccess<'de>,
419            {
420                let mut id__ = None;
421                let mut schema_id__ = None;
422                let mut database_id__ = None;
423                let mut name__ = None;
424                let mut owner__ = None;
425                let mut info__ = None;
426                while let Some(k) = map_.next_key()? {
427                    match k {
428                        GeneratedField::Id => {
429                            if id__.is_some() {
430                                return Err(serde::de::Error::duplicate_field("id"));
431                            }
432                            id__ = 
433                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
434                            ;
435                        }
436                        GeneratedField::SchemaId => {
437                            if schema_id__.is_some() {
438                                return Err(serde::de::Error::duplicate_field("schemaId"));
439                            }
440                            schema_id__ = 
441                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
442                            ;
443                        }
444                        GeneratedField::DatabaseId => {
445                            if database_id__.is_some() {
446                                return Err(serde::de::Error::duplicate_field("databaseId"));
447                            }
448                            database_id__ = 
449                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
450                            ;
451                        }
452                        GeneratedField::Name => {
453                            if name__.is_some() {
454                                return Err(serde::de::Error::duplicate_field("name"));
455                            }
456                            name__ = Some(map_.next_value()?);
457                        }
458                        GeneratedField::Owner => {
459                            if owner__.is_some() {
460                                return Err(serde::de::Error::duplicate_field("owner"));
461                            }
462                            owner__ = 
463                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
464                            ;
465                        }
466                        GeneratedField::PrivateLinkService => {
467                            if info__.is_some() {
468                                return Err(serde::de::Error::duplicate_field("privateLinkService"));
469                            }
470                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(connection::Info::PrivateLinkService)
471;
472                        }
473                        GeneratedField::ConnectionParams => {
474                            if info__.is_some() {
475                                return Err(serde::de::Error::duplicate_field("connectionParams"));
476                            }
477                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(connection::Info::ConnectionParams)
478;
479                        }
480                    }
481                }
482                Ok(Connection {
483                    id: id__.unwrap_or_default(),
484                    schema_id: schema_id__.unwrap_or_default(),
485                    database_id: database_id__.unwrap_or_default(),
486                    name: name__.unwrap_or_default(),
487                    owner: owner__.unwrap_or_default(),
488                    info: info__,
489                })
490            }
491        }
492        deserializer.deserialize_struct("catalog.Connection", FIELDS, GeneratedVisitor)
493    }
494}
495impl serde::Serialize for connection::PrivateLinkService {
496    #[allow(deprecated)]
497    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
498    where
499        S: serde::Serializer,
500    {
501        use serde::ser::SerializeStruct;
502        let mut len = 0;
503        if self.provider != 0 {
504            len += 1;
505        }
506        if !self.service_name.is_empty() {
507            len += 1;
508        }
509        if !self.endpoint_id.is_empty() {
510            len += 1;
511        }
512        if !self.dns_entries.is_empty() {
513            len += 1;
514        }
515        if !self.endpoint_dns_name.is_empty() {
516            len += 1;
517        }
518        let mut struct_ser = serializer.serialize_struct("catalog.Connection.PrivateLinkService", len)?;
519        if self.provider != 0 {
520            let v = connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
521                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
522            struct_ser.serialize_field("provider", &v)?;
523        }
524        if !self.service_name.is_empty() {
525            struct_ser.serialize_field("serviceName", &self.service_name)?;
526        }
527        if !self.endpoint_id.is_empty() {
528            struct_ser.serialize_field("endpointId", &self.endpoint_id)?;
529        }
530        if !self.dns_entries.is_empty() {
531            struct_ser.serialize_field("dnsEntries", &self.dns_entries)?;
532        }
533        if !self.endpoint_dns_name.is_empty() {
534            struct_ser.serialize_field("endpointDnsName", &self.endpoint_dns_name)?;
535        }
536        struct_ser.end()
537    }
538}
539impl<'de> serde::Deserialize<'de> for connection::PrivateLinkService {
540    #[allow(deprecated)]
541    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
542    where
543        D: serde::Deserializer<'de>,
544    {
545        const FIELDS: &[&str] = &[
546            "provider",
547            "service_name",
548            "serviceName",
549            "endpoint_id",
550            "endpointId",
551            "dns_entries",
552            "dnsEntries",
553            "endpoint_dns_name",
554            "endpointDnsName",
555        ];
556
557        #[allow(clippy::enum_variant_names)]
558        enum GeneratedField {
559            Provider,
560            ServiceName,
561            EndpointId,
562            DnsEntries,
563            EndpointDnsName,
564        }
565        impl<'de> serde::Deserialize<'de> for GeneratedField {
566            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
567            where
568                D: serde::Deserializer<'de>,
569            {
570                struct GeneratedVisitor;
571
572                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
573                    type Value = GeneratedField;
574
575                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
576                        write!(formatter, "expected one of: {:?}", &FIELDS)
577                    }
578
579                    #[allow(unused_variables)]
580                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
581                    where
582                        E: serde::de::Error,
583                    {
584                        match value {
585                            "provider" => Ok(GeneratedField::Provider),
586                            "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
587                            "endpointId" | "endpoint_id" => Ok(GeneratedField::EndpointId),
588                            "dnsEntries" | "dns_entries" => Ok(GeneratedField::DnsEntries),
589                            "endpointDnsName" | "endpoint_dns_name" => Ok(GeneratedField::EndpointDnsName),
590                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
591                        }
592                    }
593                }
594                deserializer.deserialize_identifier(GeneratedVisitor)
595            }
596        }
597        struct GeneratedVisitor;
598        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
599            type Value = connection::PrivateLinkService;
600
601            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
602                formatter.write_str("struct catalog.Connection.PrivateLinkService")
603            }
604
605            fn visit_map<V>(self, mut map_: V) -> std::result::Result<connection::PrivateLinkService, V::Error>
606                where
607                    V: serde::de::MapAccess<'de>,
608            {
609                let mut provider__ = None;
610                let mut service_name__ = None;
611                let mut endpoint_id__ = None;
612                let mut dns_entries__ = None;
613                let mut endpoint_dns_name__ = None;
614                while let Some(k) = map_.next_key()? {
615                    match k {
616                        GeneratedField::Provider => {
617                            if provider__.is_some() {
618                                return Err(serde::de::Error::duplicate_field("provider"));
619                            }
620                            provider__ = Some(map_.next_value::<connection::private_link_service::PrivateLinkProvider>()? as i32);
621                        }
622                        GeneratedField::ServiceName => {
623                            if service_name__.is_some() {
624                                return Err(serde::de::Error::duplicate_field("serviceName"));
625                            }
626                            service_name__ = Some(map_.next_value()?);
627                        }
628                        GeneratedField::EndpointId => {
629                            if endpoint_id__.is_some() {
630                                return Err(serde::de::Error::duplicate_field("endpointId"));
631                            }
632                            endpoint_id__ = Some(map_.next_value()?);
633                        }
634                        GeneratedField::DnsEntries => {
635                            if dns_entries__.is_some() {
636                                return Err(serde::de::Error::duplicate_field("dnsEntries"));
637                            }
638                            dns_entries__ = Some(
639                                map_.next_value::<std::collections::HashMap<_, _>>()?
640                            );
641                        }
642                        GeneratedField::EndpointDnsName => {
643                            if endpoint_dns_name__.is_some() {
644                                return Err(serde::de::Error::duplicate_field("endpointDnsName"));
645                            }
646                            endpoint_dns_name__ = Some(map_.next_value()?);
647                        }
648                    }
649                }
650                Ok(connection::PrivateLinkService {
651                    provider: provider__.unwrap_or_default(),
652                    service_name: service_name__.unwrap_or_default(),
653                    endpoint_id: endpoint_id__.unwrap_or_default(),
654                    dns_entries: dns_entries__.unwrap_or_default(),
655                    endpoint_dns_name: endpoint_dns_name__.unwrap_or_default(),
656                })
657            }
658        }
659        deserializer.deserialize_struct("catalog.Connection.PrivateLinkService", FIELDS, GeneratedVisitor)
660    }
661}
662impl serde::Serialize for connection::private_link_service::PrivateLinkProvider {
663    #[allow(deprecated)]
664    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
665    where
666        S: serde::Serializer,
667    {
668        let variant = match self {
669            Self::Unspecified => "UNSPECIFIED",
670            Self::Mock => "MOCK",
671            Self::Aws => "AWS",
672        };
673        serializer.serialize_str(variant)
674    }
675}
676impl<'de> serde::Deserialize<'de> for connection::private_link_service::PrivateLinkProvider {
677    #[allow(deprecated)]
678    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
679    where
680        D: serde::Deserializer<'de>,
681    {
682        const FIELDS: &[&str] = &[
683            "UNSPECIFIED",
684            "MOCK",
685            "AWS",
686        ];
687
688        struct GeneratedVisitor;
689
690        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
691            type Value = connection::private_link_service::PrivateLinkProvider;
692
693            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
694                write!(formatter, "expected one of: {:?}", &FIELDS)
695            }
696
697            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
698            where
699                E: serde::de::Error,
700            {
701                i32::try_from(v)
702                    .ok()
703                    .and_then(|x| x.try_into().ok())
704                    .ok_or_else(|| {
705                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
706                    })
707            }
708
709            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
710            where
711                E: serde::de::Error,
712            {
713                i32::try_from(v)
714                    .ok()
715                    .and_then(|x| x.try_into().ok())
716                    .ok_or_else(|| {
717                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
718                    })
719            }
720
721            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
722            where
723                E: serde::de::Error,
724            {
725                match value {
726                    "UNSPECIFIED" => Ok(connection::private_link_service::PrivateLinkProvider::Unspecified),
727                    "MOCK" => Ok(connection::private_link_service::PrivateLinkProvider::Mock),
728                    "AWS" => Ok(connection::private_link_service::PrivateLinkProvider::Aws),
729                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
730                }
731            }
732        }
733        deserializer.deserialize_any(GeneratedVisitor)
734    }
735}
736impl serde::Serialize for ConnectionParams {
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.connection_type != 0 {
745            len += 1;
746        }
747        if !self.properties.is_empty() {
748            len += 1;
749        }
750        if !self.secret_refs.is_empty() {
751            len += 1;
752        }
753        let mut struct_ser = serializer.serialize_struct("catalog.ConnectionParams", len)?;
754        if self.connection_type != 0 {
755            let v = connection_params::ConnectionType::try_from(self.connection_type)
756                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.connection_type)))?;
757            struct_ser.serialize_field("connectionType", &v)?;
758        }
759        if !self.properties.is_empty() {
760            struct_ser.serialize_field("properties", &self.properties)?;
761        }
762        if !self.secret_refs.is_empty() {
763            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
764        }
765        struct_ser.end()
766    }
767}
768impl<'de> serde::Deserialize<'de> for ConnectionParams {
769    #[allow(deprecated)]
770    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
771    where
772        D: serde::Deserializer<'de>,
773    {
774        const FIELDS: &[&str] = &[
775            "connection_type",
776            "connectionType",
777            "properties",
778            "secret_refs",
779            "secretRefs",
780        ];
781
782        #[allow(clippy::enum_variant_names)]
783        enum GeneratedField {
784            ConnectionType,
785            Properties,
786            SecretRefs,
787        }
788        impl<'de> serde::Deserialize<'de> for GeneratedField {
789            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
790            where
791                D: serde::Deserializer<'de>,
792            {
793                struct GeneratedVisitor;
794
795                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
796                    type Value = GeneratedField;
797
798                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799                        write!(formatter, "expected one of: {:?}", &FIELDS)
800                    }
801
802                    #[allow(unused_variables)]
803                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
804                    where
805                        E: serde::de::Error,
806                    {
807                        match value {
808                            "connectionType" | "connection_type" => Ok(GeneratedField::ConnectionType),
809                            "properties" => Ok(GeneratedField::Properties),
810                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
811                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
812                        }
813                    }
814                }
815                deserializer.deserialize_identifier(GeneratedVisitor)
816            }
817        }
818        struct GeneratedVisitor;
819        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
820            type Value = ConnectionParams;
821
822            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823                formatter.write_str("struct catalog.ConnectionParams")
824            }
825
826            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectionParams, V::Error>
827                where
828                    V: serde::de::MapAccess<'de>,
829            {
830                let mut connection_type__ = None;
831                let mut properties__ = None;
832                let mut secret_refs__ = None;
833                while let Some(k) = map_.next_key()? {
834                    match k {
835                        GeneratedField::ConnectionType => {
836                            if connection_type__.is_some() {
837                                return Err(serde::de::Error::duplicate_field("connectionType"));
838                            }
839                            connection_type__ = Some(map_.next_value::<connection_params::ConnectionType>()? as i32);
840                        }
841                        GeneratedField::Properties => {
842                            if properties__.is_some() {
843                                return Err(serde::de::Error::duplicate_field("properties"));
844                            }
845                            properties__ = Some(
846                                map_.next_value::<std::collections::HashMap<_, _>>()?
847                            );
848                        }
849                        GeneratedField::SecretRefs => {
850                            if secret_refs__.is_some() {
851                                return Err(serde::de::Error::duplicate_field("secretRefs"));
852                            }
853                            secret_refs__ = Some(
854                                map_.next_value::<std::collections::HashMap<_, _>>()?
855                            );
856                        }
857                    }
858                }
859                Ok(ConnectionParams {
860                    connection_type: connection_type__.unwrap_or_default(),
861                    properties: properties__.unwrap_or_default(),
862                    secret_refs: secret_refs__.unwrap_or_default(),
863                })
864            }
865        }
866        deserializer.deserialize_struct("catalog.ConnectionParams", FIELDS, GeneratedVisitor)
867    }
868}
869impl serde::Serialize for connection_params::ConnectionType {
870    #[allow(deprecated)]
871    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
872    where
873        S: serde::Serializer,
874    {
875        let variant = match self {
876            Self::Unspecified => "CONNECTION_TYPE_UNSPECIFIED",
877            Self::Kafka => "CONNECTION_TYPE_KAFKA",
878            Self::Iceberg => "CONNECTION_TYPE_ICEBERG",
879            Self::SchemaRegistry => "CONNECTION_TYPE_SCHEMA_REGISTRY",
880            Self::Elasticsearch => "CONNECTION_TYPE_ELASTICSEARCH",
881        };
882        serializer.serialize_str(variant)
883    }
884}
885impl<'de> serde::Deserialize<'de> for connection_params::ConnectionType {
886    #[allow(deprecated)]
887    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
888    where
889        D: serde::Deserializer<'de>,
890    {
891        const FIELDS: &[&str] = &[
892            "CONNECTION_TYPE_UNSPECIFIED",
893            "CONNECTION_TYPE_KAFKA",
894            "CONNECTION_TYPE_ICEBERG",
895            "CONNECTION_TYPE_SCHEMA_REGISTRY",
896            "CONNECTION_TYPE_ELASTICSEARCH",
897        ];
898
899        struct GeneratedVisitor;
900
901        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
902            type Value = connection_params::ConnectionType;
903
904            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
905                write!(formatter, "expected one of: {:?}", &FIELDS)
906            }
907
908            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
909            where
910                E: serde::de::Error,
911            {
912                i32::try_from(v)
913                    .ok()
914                    .and_then(|x| x.try_into().ok())
915                    .ok_or_else(|| {
916                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
917                    })
918            }
919
920            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
921            where
922                E: serde::de::Error,
923            {
924                i32::try_from(v)
925                    .ok()
926                    .and_then(|x| x.try_into().ok())
927                    .ok_or_else(|| {
928                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
929                    })
930            }
931
932            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
933            where
934                E: serde::de::Error,
935            {
936                match value {
937                    "CONNECTION_TYPE_UNSPECIFIED" => Ok(connection_params::ConnectionType::Unspecified),
938                    "CONNECTION_TYPE_KAFKA" => Ok(connection_params::ConnectionType::Kafka),
939                    "CONNECTION_TYPE_ICEBERG" => Ok(connection_params::ConnectionType::Iceberg),
940                    "CONNECTION_TYPE_SCHEMA_REGISTRY" => Ok(connection_params::ConnectionType::SchemaRegistry),
941                    "CONNECTION_TYPE_ELASTICSEARCH" => Ok(connection_params::ConnectionType::Elasticsearch),
942                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
943                }
944            }
945        }
946        deserializer.deserialize_any(GeneratedVisitor)
947    }
948}
949impl serde::Serialize for CreateType {
950    #[allow(deprecated)]
951    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
952    where
953        S: serde::Serializer,
954    {
955        let variant = match self {
956            Self::Unspecified => "CREATE_TYPE_UNSPECIFIED",
957            Self::Background => "CREATE_TYPE_BACKGROUND",
958            Self::Foreground => "CREATE_TYPE_FOREGROUND",
959        };
960        serializer.serialize_str(variant)
961    }
962}
963impl<'de> serde::Deserialize<'de> for CreateType {
964    #[allow(deprecated)]
965    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
966    where
967        D: serde::Deserializer<'de>,
968    {
969        const FIELDS: &[&str] = &[
970            "CREATE_TYPE_UNSPECIFIED",
971            "CREATE_TYPE_BACKGROUND",
972            "CREATE_TYPE_FOREGROUND",
973        ];
974
975        struct GeneratedVisitor;
976
977        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
978            type Value = CreateType;
979
980            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
981                write!(formatter, "expected one of: {:?}", &FIELDS)
982            }
983
984            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
985            where
986                E: serde::de::Error,
987            {
988                i32::try_from(v)
989                    .ok()
990                    .and_then(|x| x.try_into().ok())
991                    .ok_or_else(|| {
992                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
993                    })
994            }
995
996            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
997            where
998                E: serde::de::Error,
999            {
1000                i32::try_from(v)
1001                    .ok()
1002                    .and_then(|x| x.try_into().ok())
1003                    .ok_or_else(|| {
1004                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1005                    })
1006            }
1007
1008            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1009            where
1010                E: serde::de::Error,
1011            {
1012                match value {
1013                    "CREATE_TYPE_UNSPECIFIED" => Ok(CreateType::Unspecified),
1014                    "CREATE_TYPE_BACKGROUND" => Ok(CreateType::Background),
1015                    "CREATE_TYPE_FOREGROUND" => Ok(CreateType::Foreground),
1016                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1017                }
1018            }
1019        }
1020        deserializer.deserialize_any(GeneratedVisitor)
1021    }
1022}
1023impl serde::Serialize for Database {
1024    #[allow(deprecated)]
1025    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1026    where
1027        S: serde::Serializer,
1028    {
1029        use serde::ser::SerializeStruct;
1030        let mut len = 0;
1031        if self.id != 0 {
1032            len += 1;
1033        }
1034        if !self.name.is_empty() {
1035            len += 1;
1036        }
1037        if self.owner != 0 {
1038            len += 1;
1039        }
1040        if !self.resource_group.is_empty() {
1041            len += 1;
1042        }
1043        if self.barrier_interval_ms.is_some() {
1044            len += 1;
1045        }
1046        if self.checkpoint_frequency.is_some() {
1047            len += 1;
1048        }
1049        let mut struct_ser = serializer.serialize_struct("catalog.Database", len)?;
1050        if self.id != 0 {
1051            struct_ser.serialize_field("id", &self.id)?;
1052        }
1053        if !self.name.is_empty() {
1054            struct_ser.serialize_field("name", &self.name)?;
1055        }
1056        if self.owner != 0 {
1057            struct_ser.serialize_field("owner", &self.owner)?;
1058        }
1059        if !self.resource_group.is_empty() {
1060            struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
1061        }
1062        if let Some(v) = self.barrier_interval_ms.as_ref() {
1063            struct_ser.serialize_field("barrierIntervalMs", v)?;
1064        }
1065        if let Some(v) = self.checkpoint_frequency.as_ref() {
1066            #[allow(clippy::needless_borrow)]
1067            #[allow(clippy::needless_borrows_for_generic_args)]
1068            struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
1069        }
1070        struct_ser.end()
1071    }
1072}
1073impl<'de> serde::Deserialize<'de> for Database {
1074    #[allow(deprecated)]
1075    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1076    where
1077        D: serde::Deserializer<'de>,
1078    {
1079        const FIELDS: &[&str] = &[
1080            "id",
1081            "name",
1082            "owner",
1083            "resource_group",
1084            "resourceGroup",
1085            "barrier_interval_ms",
1086            "barrierIntervalMs",
1087            "checkpoint_frequency",
1088            "checkpointFrequency",
1089        ];
1090
1091        #[allow(clippy::enum_variant_names)]
1092        enum GeneratedField {
1093            Id,
1094            Name,
1095            Owner,
1096            ResourceGroup,
1097            BarrierIntervalMs,
1098            CheckpointFrequency,
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                            "id" => Ok(GeneratedField::Id),
1121                            "name" => Ok(GeneratedField::Name),
1122                            "owner" => Ok(GeneratedField::Owner),
1123                            "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1124                            "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
1125                            "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
1126                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1127                        }
1128                    }
1129                }
1130                deserializer.deserialize_identifier(GeneratedVisitor)
1131            }
1132        }
1133        struct GeneratedVisitor;
1134        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1135            type Value = Database;
1136
1137            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1138                formatter.write_str("struct catalog.Database")
1139            }
1140
1141            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Database, V::Error>
1142                where
1143                    V: serde::de::MapAccess<'de>,
1144            {
1145                let mut id__ = None;
1146                let mut name__ = None;
1147                let mut owner__ = None;
1148                let mut resource_group__ = None;
1149                let mut barrier_interval_ms__ = None;
1150                let mut checkpoint_frequency__ = None;
1151                while let Some(k) = map_.next_key()? {
1152                    match k {
1153                        GeneratedField::Id => {
1154                            if id__.is_some() {
1155                                return Err(serde::de::Error::duplicate_field("id"));
1156                            }
1157                            id__ = 
1158                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1159                            ;
1160                        }
1161                        GeneratedField::Name => {
1162                            if name__.is_some() {
1163                                return Err(serde::de::Error::duplicate_field("name"));
1164                            }
1165                            name__ = Some(map_.next_value()?);
1166                        }
1167                        GeneratedField::Owner => {
1168                            if owner__.is_some() {
1169                                return Err(serde::de::Error::duplicate_field("owner"));
1170                            }
1171                            owner__ = 
1172                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1173                            ;
1174                        }
1175                        GeneratedField::ResourceGroup => {
1176                            if resource_group__.is_some() {
1177                                return Err(serde::de::Error::duplicate_field("resourceGroup"));
1178                            }
1179                            resource_group__ = Some(map_.next_value()?);
1180                        }
1181                        GeneratedField::BarrierIntervalMs => {
1182                            if barrier_interval_ms__.is_some() {
1183                                return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
1184                            }
1185                            barrier_interval_ms__ = 
1186                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1187                            ;
1188                        }
1189                        GeneratedField::CheckpointFrequency => {
1190                            if checkpoint_frequency__.is_some() {
1191                                return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
1192                            }
1193                            checkpoint_frequency__ = 
1194                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1195                            ;
1196                        }
1197                    }
1198                }
1199                Ok(Database {
1200                    id: id__.unwrap_or_default(),
1201                    name: name__.unwrap_or_default(),
1202                    owner: owner__.unwrap_or_default(),
1203                    resource_group: resource_group__.unwrap_or_default(),
1204                    barrier_interval_ms: barrier_interval_ms__,
1205                    checkpoint_frequency: checkpoint_frequency__,
1206                })
1207            }
1208        }
1209        deserializer.deserialize_struct("catalog.Database", FIELDS, GeneratedVisitor)
1210    }
1211}
1212impl serde::Serialize for Function {
1213    #[allow(deprecated)]
1214    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1215    where
1216        S: serde::Serializer,
1217    {
1218        use serde::ser::SerializeStruct;
1219        let mut len = 0;
1220        if self.id != 0 {
1221            len += 1;
1222        }
1223        if self.schema_id != 0 {
1224            len += 1;
1225        }
1226        if self.database_id != 0 {
1227            len += 1;
1228        }
1229        if !self.name.is_empty() {
1230            len += 1;
1231        }
1232        if self.owner != 0 {
1233            len += 1;
1234        }
1235        if !self.arg_names.is_empty() {
1236            len += 1;
1237        }
1238        if !self.arg_types.is_empty() {
1239            len += 1;
1240        }
1241        if self.return_type.is_some() {
1242            len += 1;
1243        }
1244        if !self.language.is_empty() {
1245            len += 1;
1246        }
1247        if self.link.is_some() {
1248            len += 1;
1249        }
1250        if self.name_in_runtime.is_some() {
1251            len += 1;
1252        }
1253        if self.body.is_some() {
1254            len += 1;
1255        }
1256        if self.compressed_binary.is_some() {
1257            len += 1;
1258        }
1259        if self.always_retry_on_network_error {
1260            len += 1;
1261        }
1262        if self.runtime.is_some() {
1263            len += 1;
1264        }
1265        if self.is_async.is_some() {
1266            len += 1;
1267        }
1268        if self.is_batched.is_some() {
1269            len += 1;
1270        }
1271        if self.kind.is_some() {
1272            len += 1;
1273        }
1274        let mut struct_ser = serializer.serialize_struct("catalog.Function", len)?;
1275        if self.id != 0 {
1276            struct_ser.serialize_field("id", &self.id)?;
1277        }
1278        if self.schema_id != 0 {
1279            struct_ser.serialize_field("schemaId", &self.schema_id)?;
1280        }
1281        if self.database_id != 0 {
1282            struct_ser.serialize_field("databaseId", &self.database_id)?;
1283        }
1284        if !self.name.is_empty() {
1285            struct_ser.serialize_field("name", &self.name)?;
1286        }
1287        if self.owner != 0 {
1288            struct_ser.serialize_field("owner", &self.owner)?;
1289        }
1290        if !self.arg_names.is_empty() {
1291            struct_ser.serialize_field("argNames", &self.arg_names)?;
1292        }
1293        if !self.arg_types.is_empty() {
1294            struct_ser.serialize_field("argTypes", &self.arg_types)?;
1295        }
1296        if let Some(v) = self.return_type.as_ref() {
1297            struct_ser.serialize_field("returnType", v)?;
1298        }
1299        if !self.language.is_empty() {
1300            struct_ser.serialize_field("language", &self.language)?;
1301        }
1302        if let Some(v) = self.link.as_ref() {
1303            struct_ser.serialize_field("link", v)?;
1304        }
1305        if let Some(v) = self.name_in_runtime.as_ref() {
1306            struct_ser.serialize_field("nameInRuntime", v)?;
1307        }
1308        if let Some(v) = self.body.as_ref() {
1309            struct_ser.serialize_field("body", v)?;
1310        }
1311        if let Some(v) = self.compressed_binary.as_ref() {
1312            #[allow(clippy::needless_borrow)]
1313            #[allow(clippy::needless_borrows_for_generic_args)]
1314            struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
1315        }
1316        if self.always_retry_on_network_error {
1317            struct_ser.serialize_field("alwaysRetryOnNetworkError", &self.always_retry_on_network_error)?;
1318        }
1319        if let Some(v) = self.runtime.as_ref() {
1320            struct_ser.serialize_field("runtime", v)?;
1321        }
1322        if let Some(v) = self.is_async.as_ref() {
1323            struct_ser.serialize_field("isAsync", v)?;
1324        }
1325        if let Some(v) = self.is_batched.as_ref() {
1326            struct_ser.serialize_field("isBatched", v)?;
1327        }
1328        if let Some(v) = self.kind.as_ref() {
1329            match v {
1330                function::Kind::Scalar(v) => {
1331                    struct_ser.serialize_field("scalar", v)?;
1332                }
1333                function::Kind::Table(v) => {
1334                    struct_ser.serialize_field("table", v)?;
1335                }
1336                function::Kind::Aggregate(v) => {
1337                    struct_ser.serialize_field("aggregate", v)?;
1338                }
1339            }
1340        }
1341        struct_ser.end()
1342    }
1343}
1344impl<'de> serde::Deserialize<'de> for Function {
1345    #[allow(deprecated)]
1346    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1347    where
1348        D: serde::Deserializer<'de>,
1349    {
1350        const FIELDS: &[&str] = &[
1351            "id",
1352            "schema_id",
1353            "schemaId",
1354            "database_id",
1355            "databaseId",
1356            "name",
1357            "owner",
1358            "arg_names",
1359            "argNames",
1360            "arg_types",
1361            "argTypes",
1362            "return_type",
1363            "returnType",
1364            "language",
1365            "link",
1366            "name_in_runtime",
1367            "nameInRuntime",
1368            "body",
1369            "compressed_binary",
1370            "compressedBinary",
1371            "always_retry_on_network_error",
1372            "alwaysRetryOnNetworkError",
1373            "runtime",
1374            "is_async",
1375            "isAsync",
1376            "is_batched",
1377            "isBatched",
1378            "scalar",
1379            "table",
1380            "aggregate",
1381        ];
1382
1383        #[allow(clippy::enum_variant_names)]
1384        enum GeneratedField {
1385            Id,
1386            SchemaId,
1387            DatabaseId,
1388            Name,
1389            Owner,
1390            ArgNames,
1391            ArgTypes,
1392            ReturnType,
1393            Language,
1394            Link,
1395            NameInRuntime,
1396            Body,
1397            CompressedBinary,
1398            AlwaysRetryOnNetworkError,
1399            Runtime,
1400            IsAsync,
1401            IsBatched,
1402            Scalar,
1403            Table,
1404            Aggregate,
1405        }
1406        impl<'de> serde::Deserialize<'de> for GeneratedField {
1407            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1408            where
1409                D: serde::Deserializer<'de>,
1410            {
1411                struct GeneratedVisitor;
1412
1413                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1414                    type Value = GeneratedField;
1415
1416                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1417                        write!(formatter, "expected one of: {:?}", &FIELDS)
1418                    }
1419
1420                    #[allow(unused_variables)]
1421                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1422                    where
1423                        E: serde::de::Error,
1424                    {
1425                        match value {
1426                            "id" => Ok(GeneratedField::Id),
1427                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1428                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1429                            "name" => Ok(GeneratedField::Name),
1430                            "owner" => Ok(GeneratedField::Owner),
1431                            "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
1432                            "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
1433                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
1434                            "language" => Ok(GeneratedField::Language),
1435                            "link" => Ok(GeneratedField::Link),
1436                            "nameInRuntime" | "name_in_runtime" => Ok(GeneratedField::NameInRuntime),
1437                            "body" => Ok(GeneratedField::Body),
1438                            "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
1439                            "alwaysRetryOnNetworkError" | "always_retry_on_network_error" => Ok(GeneratedField::AlwaysRetryOnNetworkError),
1440                            "runtime" => Ok(GeneratedField::Runtime),
1441                            "isAsync" | "is_async" => Ok(GeneratedField::IsAsync),
1442                            "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
1443                            "scalar" => Ok(GeneratedField::Scalar),
1444                            "table" => Ok(GeneratedField::Table),
1445                            "aggregate" => Ok(GeneratedField::Aggregate),
1446                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1447                        }
1448                    }
1449                }
1450                deserializer.deserialize_identifier(GeneratedVisitor)
1451            }
1452        }
1453        struct GeneratedVisitor;
1454        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1455            type Value = Function;
1456
1457            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1458                formatter.write_str("struct catalog.Function")
1459            }
1460
1461            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Function, V::Error>
1462                where
1463                    V: serde::de::MapAccess<'de>,
1464            {
1465                let mut id__ = None;
1466                let mut schema_id__ = None;
1467                let mut database_id__ = None;
1468                let mut name__ = None;
1469                let mut owner__ = None;
1470                let mut arg_names__ = None;
1471                let mut arg_types__ = None;
1472                let mut return_type__ = None;
1473                let mut language__ = None;
1474                let mut link__ = None;
1475                let mut name_in_runtime__ = None;
1476                let mut body__ = None;
1477                let mut compressed_binary__ = None;
1478                let mut always_retry_on_network_error__ = None;
1479                let mut runtime__ = None;
1480                let mut is_async__ = None;
1481                let mut is_batched__ = None;
1482                let mut kind__ = None;
1483                while let Some(k) = map_.next_key()? {
1484                    match k {
1485                        GeneratedField::Id => {
1486                            if id__.is_some() {
1487                                return Err(serde::de::Error::duplicate_field("id"));
1488                            }
1489                            id__ = 
1490                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1491                            ;
1492                        }
1493                        GeneratedField::SchemaId => {
1494                            if schema_id__.is_some() {
1495                                return Err(serde::de::Error::duplicate_field("schemaId"));
1496                            }
1497                            schema_id__ = 
1498                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1499                            ;
1500                        }
1501                        GeneratedField::DatabaseId => {
1502                            if database_id__.is_some() {
1503                                return Err(serde::de::Error::duplicate_field("databaseId"));
1504                            }
1505                            database_id__ = 
1506                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1507                            ;
1508                        }
1509                        GeneratedField::Name => {
1510                            if name__.is_some() {
1511                                return Err(serde::de::Error::duplicate_field("name"));
1512                            }
1513                            name__ = Some(map_.next_value()?);
1514                        }
1515                        GeneratedField::Owner => {
1516                            if owner__.is_some() {
1517                                return Err(serde::de::Error::duplicate_field("owner"));
1518                            }
1519                            owner__ = 
1520                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1521                            ;
1522                        }
1523                        GeneratedField::ArgNames => {
1524                            if arg_names__.is_some() {
1525                                return Err(serde::de::Error::duplicate_field("argNames"));
1526                            }
1527                            arg_names__ = Some(map_.next_value()?);
1528                        }
1529                        GeneratedField::ArgTypes => {
1530                            if arg_types__.is_some() {
1531                                return Err(serde::de::Error::duplicate_field("argTypes"));
1532                            }
1533                            arg_types__ = Some(map_.next_value()?);
1534                        }
1535                        GeneratedField::ReturnType => {
1536                            if return_type__.is_some() {
1537                                return Err(serde::de::Error::duplicate_field("returnType"));
1538                            }
1539                            return_type__ = map_.next_value()?;
1540                        }
1541                        GeneratedField::Language => {
1542                            if language__.is_some() {
1543                                return Err(serde::de::Error::duplicate_field("language"));
1544                            }
1545                            language__ = Some(map_.next_value()?);
1546                        }
1547                        GeneratedField::Link => {
1548                            if link__.is_some() {
1549                                return Err(serde::de::Error::duplicate_field("link"));
1550                            }
1551                            link__ = map_.next_value()?;
1552                        }
1553                        GeneratedField::NameInRuntime => {
1554                            if name_in_runtime__.is_some() {
1555                                return Err(serde::de::Error::duplicate_field("nameInRuntime"));
1556                            }
1557                            name_in_runtime__ = map_.next_value()?;
1558                        }
1559                        GeneratedField::Body => {
1560                            if body__.is_some() {
1561                                return Err(serde::de::Error::duplicate_field("body"));
1562                            }
1563                            body__ = map_.next_value()?;
1564                        }
1565                        GeneratedField::CompressedBinary => {
1566                            if compressed_binary__.is_some() {
1567                                return Err(serde::de::Error::duplicate_field("compressedBinary"));
1568                            }
1569                            compressed_binary__ = 
1570                                map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
1571                            ;
1572                        }
1573                        GeneratedField::AlwaysRetryOnNetworkError => {
1574                            if always_retry_on_network_error__.is_some() {
1575                                return Err(serde::de::Error::duplicate_field("alwaysRetryOnNetworkError"));
1576                            }
1577                            always_retry_on_network_error__ = Some(map_.next_value()?);
1578                        }
1579                        GeneratedField::Runtime => {
1580                            if runtime__.is_some() {
1581                                return Err(serde::de::Error::duplicate_field("runtime"));
1582                            }
1583                            runtime__ = map_.next_value()?;
1584                        }
1585                        GeneratedField::IsAsync => {
1586                            if is_async__.is_some() {
1587                                return Err(serde::de::Error::duplicate_field("isAsync"));
1588                            }
1589                            is_async__ = map_.next_value()?;
1590                        }
1591                        GeneratedField::IsBatched => {
1592                            if is_batched__.is_some() {
1593                                return Err(serde::de::Error::duplicate_field("isBatched"));
1594                            }
1595                            is_batched__ = map_.next_value()?;
1596                        }
1597                        GeneratedField::Scalar => {
1598                            if kind__.is_some() {
1599                                return Err(serde::de::Error::duplicate_field("scalar"));
1600                            }
1601                            kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Scalar)
1602;
1603                        }
1604                        GeneratedField::Table => {
1605                            if kind__.is_some() {
1606                                return Err(serde::de::Error::duplicate_field("table"));
1607                            }
1608                            kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Table)
1609;
1610                        }
1611                        GeneratedField::Aggregate => {
1612                            if kind__.is_some() {
1613                                return Err(serde::de::Error::duplicate_field("aggregate"));
1614                            }
1615                            kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Aggregate)
1616;
1617                        }
1618                    }
1619                }
1620                Ok(Function {
1621                    id: id__.unwrap_or_default(),
1622                    schema_id: schema_id__.unwrap_or_default(),
1623                    database_id: database_id__.unwrap_or_default(),
1624                    name: name__.unwrap_or_default(),
1625                    owner: owner__.unwrap_or_default(),
1626                    arg_names: arg_names__.unwrap_or_default(),
1627                    arg_types: arg_types__.unwrap_or_default(),
1628                    return_type: return_type__,
1629                    language: language__.unwrap_or_default(),
1630                    link: link__,
1631                    name_in_runtime: name_in_runtime__,
1632                    body: body__,
1633                    compressed_binary: compressed_binary__,
1634                    always_retry_on_network_error: always_retry_on_network_error__.unwrap_or_default(),
1635                    runtime: runtime__,
1636                    is_async: is_async__,
1637                    is_batched: is_batched__,
1638                    kind: kind__,
1639                })
1640            }
1641        }
1642        deserializer.deserialize_struct("catalog.Function", FIELDS, GeneratedVisitor)
1643    }
1644}
1645impl serde::Serialize for function::AggregateFunction {
1646    #[allow(deprecated)]
1647    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1648    where
1649        S: serde::Serializer,
1650    {
1651        use serde::ser::SerializeStruct;
1652        let len = 0;
1653        let struct_ser = serializer.serialize_struct("catalog.Function.AggregateFunction", len)?;
1654        struct_ser.end()
1655    }
1656}
1657impl<'de> serde::Deserialize<'de> for function::AggregateFunction {
1658    #[allow(deprecated)]
1659    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1660    where
1661        D: serde::Deserializer<'de>,
1662    {
1663        const FIELDS: &[&str] = &[
1664        ];
1665
1666        #[allow(clippy::enum_variant_names)]
1667        enum GeneratedField {
1668        }
1669        impl<'de> serde::Deserialize<'de> for GeneratedField {
1670            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1671            where
1672                D: serde::Deserializer<'de>,
1673            {
1674                struct GeneratedVisitor;
1675
1676                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1677                    type Value = GeneratedField;
1678
1679                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1680                        write!(formatter, "expected one of: {:?}", &FIELDS)
1681                    }
1682
1683                    #[allow(unused_variables)]
1684                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1685                    where
1686                        E: serde::de::Error,
1687                    {
1688                            Err(serde::de::Error::unknown_field(value, FIELDS))
1689                    }
1690                }
1691                deserializer.deserialize_identifier(GeneratedVisitor)
1692            }
1693        }
1694        struct GeneratedVisitor;
1695        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1696            type Value = function::AggregateFunction;
1697
1698            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1699                formatter.write_str("struct catalog.Function.AggregateFunction")
1700            }
1701
1702            fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::AggregateFunction, V::Error>
1703                where
1704                    V: serde::de::MapAccess<'de>,
1705            {
1706                while map_.next_key::<GeneratedField>()?.is_some() {
1707                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1708                }
1709                Ok(function::AggregateFunction {
1710                })
1711            }
1712        }
1713        deserializer.deserialize_struct("catalog.Function.AggregateFunction", FIELDS, GeneratedVisitor)
1714    }
1715}
1716impl serde::Serialize for function::ScalarFunction {
1717    #[allow(deprecated)]
1718    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1719    where
1720        S: serde::Serializer,
1721    {
1722        use serde::ser::SerializeStruct;
1723        let len = 0;
1724        let struct_ser = serializer.serialize_struct("catalog.Function.ScalarFunction", len)?;
1725        struct_ser.end()
1726    }
1727}
1728impl<'de> serde::Deserialize<'de> for function::ScalarFunction {
1729    #[allow(deprecated)]
1730    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1731    where
1732        D: serde::Deserializer<'de>,
1733    {
1734        const FIELDS: &[&str] = &[
1735        ];
1736
1737        #[allow(clippy::enum_variant_names)]
1738        enum GeneratedField {
1739        }
1740        impl<'de> serde::Deserialize<'de> for GeneratedField {
1741            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1742            where
1743                D: serde::Deserializer<'de>,
1744            {
1745                struct GeneratedVisitor;
1746
1747                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1748                    type Value = GeneratedField;
1749
1750                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1751                        write!(formatter, "expected one of: {:?}", &FIELDS)
1752                    }
1753
1754                    #[allow(unused_variables)]
1755                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1756                    where
1757                        E: serde::de::Error,
1758                    {
1759                            Err(serde::de::Error::unknown_field(value, FIELDS))
1760                    }
1761                }
1762                deserializer.deserialize_identifier(GeneratedVisitor)
1763            }
1764        }
1765        struct GeneratedVisitor;
1766        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1767            type Value = function::ScalarFunction;
1768
1769            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1770                formatter.write_str("struct catalog.Function.ScalarFunction")
1771            }
1772
1773            fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::ScalarFunction, V::Error>
1774                where
1775                    V: serde::de::MapAccess<'de>,
1776            {
1777                while map_.next_key::<GeneratedField>()?.is_some() {
1778                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1779                }
1780                Ok(function::ScalarFunction {
1781                })
1782            }
1783        }
1784        deserializer.deserialize_struct("catalog.Function.ScalarFunction", FIELDS, GeneratedVisitor)
1785    }
1786}
1787impl serde::Serialize for function::TableFunction {
1788    #[allow(deprecated)]
1789    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1790    where
1791        S: serde::Serializer,
1792    {
1793        use serde::ser::SerializeStruct;
1794        let len = 0;
1795        let struct_ser = serializer.serialize_struct("catalog.Function.TableFunction", len)?;
1796        struct_ser.end()
1797    }
1798}
1799impl<'de> serde::Deserialize<'de> for function::TableFunction {
1800    #[allow(deprecated)]
1801    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1802    where
1803        D: serde::Deserializer<'de>,
1804    {
1805        const FIELDS: &[&str] = &[
1806        ];
1807
1808        #[allow(clippy::enum_variant_names)]
1809        enum GeneratedField {
1810        }
1811        impl<'de> serde::Deserialize<'de> for GeneratedField {
1812            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1813            where
1814                D: serde::Deserializer<'de>,
1815            {
1816                struct GeneratedVisitor;
1817
1818                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1819                    type Value = GeneratedField;
1820
1821                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1822                        write!(formatter, "expected one of: {:?}", &FIELDS)
1823                    }
1824
1825                    #[allow(unused_variables)]
1826                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1827                    where
1828                        E: serde::de::Error,
1829                    {
1830                            Err(serde::de::Error::unknown_field(value, FIELDS))
1831                    }
1832                }
1833                deserializer.deserialize_identifier(GeneratedVisitor)
1834            }
1835        }
1836        struct GeneratedVisitor;
1837        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1838            type Value = function::TableFunction;
1839
1840            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1841                formatter.write_str("struct catalog.Function.TableFunction")
1842            }
1843
1844            fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::TableFunction, V::Error>
1845                where
1846                    V: serde::de::MapAccess<'de>,
1847            {
1848                while map_.next_key::<GeneratedField>()?.is_some() {
1849                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1850                }
1851                Ok(function::TableFunction {
1852                })
1853            }
1854        }
1855        deserializer.deserialize_struct("catalog.Function.TableFunction", FIELDS, GeneratedVisitor)
1856    }
1857}
1858impl serde::Serialize for HandleConflictBehavior {
1859    #[allow(deprecated)]
1860    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1861    where
1862        S: serde::Serializer,
1863    {
1864        let variant = match self {
1865            Self::Unspecified => "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED",
1866            Self::Overwrite => "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE",
1867            Self::Ignore => "HANDLE_CONFLICT_BEHAVIOR_IGNORE",
1868            Self::NoCheck => "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK",
1869            Self::DoUpdateIfNotNull => "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL",
1870        };
1871        serializer.serialize_str(variant)
1872    }
1873}
1874impl<'de> serde::Deserialize<'de> for HandleConflictBehavior {
1875    #[allow(deprecated)]
1876    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1877    where
1878        D: serde::Deserializer<'de>,
1879    {
1880        const FIELDS: &[&str] = &[
1881            "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED",
1882            "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE",
1883            "HANDLE_CONFLICT_BEHAVIOR_IGNORE",
1884            "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK",
1885            "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL",
1886        ];
1887
1888        struct GeneratedVisitor;
1889
1890        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1891            type Value = HandleConflictBehavior;
1892
1893            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1894                write!(formatter, "expected one of: {:?}", &FIELDS)
1895            }
1896
1897            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1898            where
1899                E: serde::de::Error,
1900            {
1901                i32::try_from(v)
1902                    .ok()
1903                    .and_then(|x| x.try_into().ok())
1904                    .ok_or_else(|| {
1905                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1906                    })
1907            }
1908
1909            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1910            where
1911                E: serde::de::Error,
1912            {
1913                i32::try_from(v)
1914                    .ok()
1915                    .and_then(|x| x.try_into().ok())
1916                    .ok_or_else(|| {
1917                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1918                    })
1919            }
1920
1921            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1922            where
1923                E: serde::de::Error,
1924            {
1925                match value {
1926                    "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED" => Ok(HandleConflictBehavior::Unspecified),
1927                    "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE" => Ok(HandleConflictBehavior::Overwrite),
1928                    "HANDLE_CONFLICT_BEHAVIOR_IGNORE" => Ok(HandleConflictBehavior::Ignore),
1929                    "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK" => Ok(HandleConflictBehavior::NoCheck),
1930                    "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL" => Ok(HandleConflictBehavior::DoUpdateIfNotNull),
1931                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1932                }
1933            }
1934        }
1935        deserializer.deserialize_any(GeneratedVisitor)
1936    }
1937}
1938impl serde::Serialize for Index {
1939    #[allow(deprecated)]
1940    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1941    where
1942        S: serde::Serializer,
1943    {
1944        use serde::ser::SerializeStruct;
1945        let mut len = 0;
1946        if self.id != 0 {
1947            len += 1;
1948        }
1949        if self.schema_id != 0 {
1950            len += 1;
1951        }
1952        if self.database_id != 0 {
1953            len += 1;
1954        }
1955        if !self.name.is_empty() {
1956            len += 1;
1957        }
1958        if self.owner != 0 {
1959            len += 1;
1960        }
1961        if self.index_table_id != 0 {
1962            len += 1;
1963        }
1964        if self.primary_table_id != 0 {
1965            len += 1;
1966        }
1967        if !self.index_item.is_empty() {
1968            len += 1;
1969        }
1970        if !self.index_column_properties.is_empty() {
1971            len += 1;
1972        }
1973        if self.initialized_at_epoch.is_some() {
1974            len += 1;
1975        }
1976        if self.created_at_epoch.is_some() {
1977            len += 1;
1978        }
1979        if self.stream_job_status != 0 {
1980            len += 1;
1981        }
1982        if self.index_columns_len != 0 {
1983            len += 1;
1984        }
1985        if self.initialized_at_cluster_version.is_some() {
1986            len += 1;
1987        }
1988        if self.created_at_cluster_version.is_some() {
1989            len += 1;
1990        }
1991        let mut struct_ser = serializer.serialize_struct("catalog.Index", len)?;
1992        if self.id != 0 {
1993            struct_ser.serialize_field("id", &self.id)?;
1994        }
1995        if self.schema_id != 0 {
1996            struct_ser.serialize_field("schemaId", &self.schema_id)?;
1997        }
1998        if self.database_id != 0 {
1999            struct_ser.serialize_field("databaseId", &self.database_id)?;
2000        }
2001        if !self.name.is_empty() {
2002            struct_ser.serialize_field("name", &self.name)?;
2003        }
2004        if self.owner != 0 {
2005            struct_ser.serialize_field("owner", &self.owner)?;
2006        }
2007        if self.index_table_id != 0 {
2008            struct_ser.serialize_field("indexTableId", &self.index_table_id)?;
2009        }
2010        if self.primary_table_id != 0 {
2011            struct_ser.serialize_field("primaryTableId", &self.primary_table_id)?;
2012        }
2013        if !self.index_item.is_empty() {
2014            struct_ser.serialize_field("indexItem", &self.index_item)?;
2015        }
2016        if !self.index_column_properties.is_empty() {
2017            struct_ser.serialize_field("indexColumnProperties", &self.index_column_properties)?;
2018        }
2019        if let Some(v) = self.initialized_at_epoch.as_ref() {
2020            #[allow(clippy::needless_borrow)]
2021            #[allow(clippy::needless_borrows_for_generic_args)]
2022            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
2023        }
2024        if let Some(v) = self.created_at_epoch.as_ref() {
2025            #[allow(clippy::needless_borrow)]
2026            #[allow(clippy::needless_borrows_for_generic_args)]
2027            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
2028        }
2029        if self.stream_job_status != 0 {
2030            let v = StreamJobStatus::try_from(self.stream_job_status)
2031                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
2032            struct_ser.serialize_field("streamJobStatus", &v)?;
2033        }
2034        if self.index_columns_len != 0 {
2035            struct_ser.serialize_field("indexColumnsLen", &self.index_columns_len)?;
2036        }
2037        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
2038            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
2039        }
2040        if let Some(v) = self.created_at_cluster_version.as_ref() {
2041            struct_ser.serialize_field("createdAtClusterVersion", v)?;
2042        }
2043        struct_ser.end()
2044    }
2045}
2046impl<'de> serde::Deserialize<'de> for Index {
2047    #[allow(deprecated)]
2048    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2049    where
2050        D: serde::Deserializer<'de>,
2051    {
2052        const FIELDS: &[&str] = &[
2053            "id",
2054            "schema_id",
2055            "schemaId",
2056            "database_id",
2057            "databaseId",
2058            "name",
2059            "owner",
2060            "index_table_id",
2061            "indexTableId",
2062            "primary_table_id",
2063            "primaryTableId",
2064            "index_item",
2065            "indexItem",
2066            "index_column_properties",
2067            "indexColumnProperties",
2068            "initialized_at_epoch",
2069            "initializedAtEpoch",
2070            "created_at_epoch",
2071            "createdAtEpoch",
2072            "stream_job_status",
2073            "streamJobStatus",
2074            "index_columns_len",
2075            "indexColumnsLen",
2076            "initialized_at_cluster_version",
2077            "initializedAtClusterVersion",
2078            "created_at_cluster_version",
2079            "createdAtClusterVersion",
2080        ];
2081
2082        #[allow(clippy::enum_variant_names)]
2083        enum GeneratedField {
2084            Id,
2085            SchemaId,
2086            DatabaseId,
2087            Name,
2088            Owner,
2089            IndexTableId,
2090            PrimaryTableId,
2091            IndexItem,
2092            IndexColumnProperties,
2093            InitializedAtEpoch,
2094            CreatedAtEpoch,
2095            StreamJobStatus,
2096            IndexColumnsLen,
2097            InitializedAtClusterVersion,
2098            CreatedAtClusterVersion,
2099        }
2100        impl<'de> serde::Deserialize<'de> for GeneratedField {
2101            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2102            where
2103                D: serde::Deserializer<'de>,
2104            {
2105                struct GeneratedVisitor;
2106
2107                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2108                    type Value = GeneratedField;
2109
2110                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2111                        write!(formatter, "expected one of: {:?}", &FIELDS)
2112                    }
2113
2114                    #[allow(unused_variables)]
2115                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2116                    where
2117                        E: serde::de::Error,
2118                    {
2119                        match value {
2120                            "id" => Ok(GeneratedField::Id),
2121                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2122                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2123                            "name" => Ok(GeneratedField::Name),
2124                            "owner" => Ok(GeneratedField::Owner),
2125                            "indexTableId" | "index_table_id" => Ok(GeneratedField::IndexTableId),
2126                            "primaryTableId" | "primary_table_id" => Ok(GeneratedField::PrimaryTableId),
2127                            "indexItem" | "index_item" => Ok(GeneratedField::IndexItem),
2128                            "indexColumnProperties" | "index_column_properties" => Ok(GeneratedField::IndexColumnProperties),
2129                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
2130                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
2131                            "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
2132                            "indexColumnsLen" | "index_columns_len" => Ok(GeneratedField::IndexColumnsLen),
2133                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
2134                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
2135                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2136                        }
2137                    }
2138                }
2139                deserializer.deserialize_identifier(GeneratedVisitor)
2140            }
2141        }
2142        struct GeneratedVisitor;
2143        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2144            type Value = Index;
2145
2146            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2147                formatter.write_str("struct catalog.Index")
2148            }
2149
2150            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Index, V::Error>
2151                where
2152                    V: serde::de::MapAccess<'de>,
2153            {
2154                let mut id__ = None;
2155                let mut schema_id__ = None;
2156                let mut database_id__ = None;
2157                let mut name__ = None;
2158                let mut owner__ = None;
2159                let mut index_table_id__ = None;
2160                let mut primary_table_id__ = None;
2161                let mut index_item__ = None;
2162                let mut index_column_properties__ = None;
2163                let mut initialized_at_epoch__ = None;
2164                let mut created_at_epoch__ = None;
2165                let mut stream_job_status__ = None;
2166                let mut index_columns_len__ = None;
2167                let mut initialized_at_cluster_version__ = None;
2168                let mut created_at_cluster_version__ = None;
2169                while let Some(k) = map_.next_key()? {
2170                    match k {
2171                        GeneratedField::Id => {
2172                            if id__.is_some() {
2173                                return Err(serde::de::Error::duplicate_field("id"));
2174                            }
2175                            id__ = 
2176                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2177                            ;
2178                        }
2179                        GeneratedField::SchemaId => {
2180                            if schema_id__.is_some() {
2181                                return Err(serde::de::Error::duplicate_field("schemaId"));
2182                            }
2183                            schema_id__ = 
2184                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2185                            ;
2186                        }
2187                        GeneratedField::DatabaseId => {
2188                            if database_id__.is_some() {
2189                                return Err(serde::de::Error::duplicate_field("databaseId"));
2190                            }
2191                            database_id__ = 
2192                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2193                            ;
2194                        }
2195                        GeneratedField::Name => {
2196                            if name__.is_some() {
2197                                return Err(serde::de::Error::duplicate_field("name"));
2198                            }
2199                            name__ = Some(map_.next_value()?);
2200                        }
2201                        GeneratedField::Owner => {
2202                            if owner__.is_some() {
2203                                return Err(serde::de::Error::duplicate_field("owner"));
2204                            }
2205                            owner__ = 
2206                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2207                            ;
2208                        }
2209                        GeneratedField::IndexTableId => {
2210                            if index_table_id__.is_some() {
2211                                return Err(serde::de::Error::duplicate_field("indexTableId"));
2212                            }
2213                            index_table_id__ = 
2214                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2215                            ;
2216                        }
2217                        GeneratedField::PrimaryTableId => {
2218                            if primary_table_id__.is_some() {
2219                                return Err(serde::de::Error::duplicate_field("primaryTableId"));
2220                            }
2221                            primary_table_id__ = 
2222                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2223                            ;
2224                        }
2225                        GeneratedField::IndexItem => {
2226                            if index_item__.is_some() {
2227                                return Err(serde::de::Error::duplicate_field("indexItem"));
2228                            }
2229                            index_item__ = Some(map_.next_value()?);
2230                        }
2231                        GeneratedField::IndexColumnProperties => {
2232                            if index_column_properties__.is_some() {
2233                                return Err(serde::de::Error::duplicate_field("indexColumnProperties"));
2234                            }
2235                            index_column_properties__ = Some(map_.next_value()?);
2236                        }
2237                        GeneratedField::InitializedAtEpoch => {
2238                            if initialized_at_epoch__.is_some() {
2239                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
2240                            }
2241                            initialized_at_epoch__ = 
2242                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2243                            ;
2244                        }
2245                        GeneratedField::CreatedAtEpoch => {
2246                            if created_at_epoch__.is_some() {
2247                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
2248                            }
2249                            created_at_epoch__ = 
2250                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2251                            ;
2252                        }
2253                        GeneratedField::StreamJobStatus => {
2254                            if stream_job_status__.is_some() {
2255                                return Err(serde::de::Error::duplicate_field("streamJobStatus"));
2256                            }
2257                            stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
2258                        }
2259                        GeneratedField::IndexColumnsLen => {
2260                            if index_columns_len__.is_some() {
2261                                return Err(serde::de::Error::duplicate_field("indexColumnsLen"));
2262                            }
2263                            index_columns_len__ = 
2264                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2265                            ;
2266                        }
2267                        GeneratedField::InitializedAtClusterVersion => {
2268                            if initialized_at_cluster_version__.is_some() {
2269                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
2270                            }
2271                            initialized_at_cluster_version__ = map_.next_value()?;
2272                        }
2273                        GeneratedField::CreatedAtClusterVersion => {
2274                            if created_at_cluster_version__.is_some() {
2275                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
2276                            }
2277                            created_at_cluster_version__ = map_.next_value()?;
2278                        }
2279                    }
2280                }
2281                Ok(Index {
2282                    id: id__.unwrap_or_default(),
2283                    schema_id: schema_id__.unwrap_or_default(),
2284                    database_id: database_id__.unwrap_or_default(),
2285                    name: name__.unwrap_or_default(),
2286                    owner: owner__.unwrap_or_default(),
2287                    index_table_id: index_table_id__.unwrap_or_default(),
2288                    primary_table_id: primary_table_id__.unwrap_or_default(),
2289                    index_item: index_item__.unwrap_or_default(),
2290                    index_column_properties: index_column_properties__.unwrap_or_default(),
2291                    initialized_at_epoch: initialized_at_epoch__,
2292                    created_at_epoch: created_at_epoch__,
2293                    stream_job_status: stream_job_status__.unwrap_or_default(),
2294                    index_columns_len: index_columns_len__.unwrap_or_default(),
2295                    initialized_at_cluster_version: initialized_at_cluster_version__,
2296                    created_at_cluster_version: created_at_cluster_version__,
2297                })
2298            }
2299        }
2300        deserializer.deserialize_struct("catalog.Index", FIELDS, GeneratedVisitor)
2301    }
2302}
2303impl serde::Serialize for IndexColumnProperties {
2304    #[allow(deprecated)]
2305    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2306    where
2307        S: serde::Serializer,
2308    {
2309        use serde::ser::SerializeStruct;
2310        let mut len = 0;
2311        if self.is_desc {
2312            len += 1;
2313        }
2314        if self.nulls_first {
2315            len += 1;
2316        }
2317        let mut struct_ser = serializer.serialize_struct("catalog.IndexColumnProperties", len)?;
2318        if self.is_desc {
2319            struct_ser.serialize_field("isDesc", &self.is_desc)?;
2320        }
2321        if self.nulls_first {
2322            struct_ser.serialize_field("nullsFirst", &self.nulls_first)?;
2323        }
2324        struct_ser.end()
2325    }
2326}
2327impl<'de> serde::Deserialize<'de> for IndexColumnProperties {
2328    #[allow(deprecated)]
2329    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2330    where
2331        D: serde::Deserializer<'de>,
2332    {
2333        const FIELDS: &[&str] = &[
2334            "is_desc",
2335            "isDesc",
2336            "nulls_first",
2337            "nullsFirst",
2338        ];
2339
2340        #[allow(clippy::enum_variant_names)]
2341        enum GeneratedField {
2342            IsDesc,
2343            NullsFirst,
2344        }
2345        impl<'de> serde::Deserialize<'de> for GeneratedField {
2346            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2347            where
2348                D: serde::Deserializer<'de>,
2349            {
2350                struct GeneratedVisitor;
2351
2352                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2353                    type Value = GeneratedField;
2354
2355                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2356                        write!(formatter, "expected one of: {:?}", &FIELDS)
2357                    }
2358
2359                    #[allow(unused_variables)]
2360                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2361                    where
2362                        E: serde::de::Error,
2363                    {
2364                        match value {
2365                            "isDesc" | "is_desc" => Ok(GeneratedField::IsDesc),
2366                            "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
2367                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2368                        }
2369                    }
2370                }
2371                deserializer.deserialize_identifier(GeneratedVisitor)
2372            }
2373        }
2374        struct GeneratedVisitor;
2375        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2376            type Value = IndexColumnProperties;
2377
2378            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2379                formatter.write_str("struct catalog.IndexColumnProperties")
2380            }
2381
2382            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IndexColumnProperties, V::Error>
2383                where
2384                    V: serde::de::MapAccess<'de>,
2385            {
2386                let mut is_desc__ = None;
2387                let mut nulls_first__ = None;
2388                while let Some(k) = map_.next_key()? {
2389                    match k {
2390                        GeneratedField::IsDesc => {
2391                            if is_desc__.is_some() {
2392                                return Err(serde::de::Error::duplicate_field("isDesc"));
2393                            }
2394                            is_desc__ = Some(map_.next_value()?);
2395                        }
2396                        GeneratedField::NullsFirst => {
2397                            if nulls_first__.is_some() {
2398                                return Err(serde::de::Error::duplicate_field("nullsFirst"));
2399                            }
2400                            nulls_first__ = Some(map_.next_value()?);
2401                        }
2402                    }
2403                }
2404                Ok(IndexColumnProperties {
2405                    is_desc: is_desc__.unwrap_or_default(),
2406                    nulls_first: nulls_first__.unwrap_or_default(),
2407                })
2408            }
2409        }
2410        deserializer.deserialize_struct("catalog.IndexColumnProperties", FIELDS, GeneratedVisitor)
2411    }
2412}
2413impl serde::Serialize for OptionsWithSecret {
2414    #[allow(deprecated)]
2415    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2416    where
2417        S: serde::Serializer,
2418    {
2419        use serde::ser::SerializeStruct;
2420        let mut len = 0;
2421        if !self.options.is_empty() {
2422            len += 1;
2423        }
2424        if !self.secret_refs.is_empty() {
2425            len += 1;
2426        }
2427        let mut struct_ser = serializer.serialize_struct("catalog.OptionsWithSecret", len)?;
2428        if !self.options.is_empty() {
2429            struct_ser.serialize_field("options", &self.options)?;
2430        }
2431        if !self.secret_refs.is_empty() {
2432            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
2433        }
2434        struct_ser.end()
2435    }
2436}
2437impl<'de> serde::Deserialize<'de> for OptionsWithSecret {
2438    #[allow(deprecated)]
2439    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2440    where
2441        D: serde::Deserializer<'de>,
2442    {
2443        const FIELDS: &[&str] = &[
2444            "options",
2445            "secret_refs",
2446            "secretRefs",
2447        ];
2448
2449        #[allow(clippy::enum_variant_names)]
2450        enum GeneratedField {
2451            Options,
2452            SecretRefs,
2453        }
2454        impl<'de> serde::Deserialize<'de> for GeneratedField {
2455            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2456            where
2457                D: serde::Deserializer<'de>,
2458            {
2459                struct GeneratedVisitor;
2460
2461                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2462                    type Value = GeneratedField;
2463
2464                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2465                        write!(formatter, "expected one of: {:?}", &FIELDS)
2466                    }
2467
2468                    #[allow(unused_variables)]
2469                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2470                    where
2471                        E: serde::de::Error,
2472                    {
2473                        match value {
2474                            "options" => Ok(GeneratedField::Options),
2475                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
2476                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2477                        }
2478                    }
2479                }
2480                deserializer.deserialize_identifier(GeneratedVisitor)
2481            }
2482        }
2483        struct GeneratedVisitor;
2484        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2485            type Value = OptionsWithSecret;
2486
2487            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2488                formatter.write_str("struct catalog.OptionsWithSecret")
2489            }
2490
2491            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionsWithSecret, V::Error>
2492                where
2493                    V: serde::de::MapAccess<'de>,
2494            {
2495                let mut options__ = None;
2496                let mut secret_refs__ = None;
2497                while let Some(k) = map_.next_key()? {
2498                    match k {
2499                        GeneratedField::Options => {
2500                            if options__.is_some() {
2501                                return Err(serde::de::Error::duplicate_field("options"));
2502                            }
2503                            options__ = Some(
2504                                map_.next_value::<std::collections::HashMap<_, _>>()?
2505                            );
2506                        }
2507                        GeneratedField::SecretRefs => {
2508                            if secret_refs__.is_some() {
2509                                return Err(serde::de::Error::duplicate_field("secretRefs"));
2510                            }
2511                            secret_refs__ = Some(
2512                                map_.next_value::<std::collections::HashMap<_, _>>()?
2513                            );
2514                        }
2515                    }
2516                }
2517                Ok(OptionsWithSecret {
2518                    options: options__.unwrap_or_default(),
2519                    secret_refs: secret_refs__.unwrap_or_default(),
2520                })
2521            }
2522        }
2523        deserializer.deserialize_struct("catalog.OptionsWithSecret", FIELDS, GeneratedVisitor)
2524    }
2525}
2526impl serde::Serialize for Schema {
2527    #[allow(deprecated)]
2528    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2529    where
2530        S: serde::Serializer,
2531    {
2532        use serde::ser::SerializeStruct;
2533        let mut len = 0;
2534        if self.id != 0 {
2535            len += 1;
2536        }
2537        if self.database_id != 0 {
2538            len += 1;
2539        }
2540        if !self.name.is_empty() {
2541            len += 1;
2542        }
2543        if self.owner != 0 {
2544            len += 1;
2545        }
2546        let mut struct_ser = serializer.serialize_struct("catalog.Schema", len)?;
2547        if self.id != 0 {
2548            struct_ser.serialize_field("id", &self.id)?;
2549        }
2550        if self.database_id != 0 {
2551            struct_ser.serialize_field("databaseId", &self.database_id)?;
2552        }
2553        if !self.name.is_empty() {
2554            struct_ser.serialize_field("name", &self.name)?;
2555        }
2556        if self.owner != 0 {
2557            struct_ser.serialize_field("owner", &self.owner)?;
2558        }
2559        struct_ser.end()
2560    }
2561}
2562impl<'de> serde::Deserialize<'de> for Schema {
2563    #[allow(deprecated)]
2564    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2565    where
2566        D: serde::Deserializer<'de>,
2567    {
2568        const FIELDS: &[&str] = &[
2569            "id",
2570            "database_id",
2571            "databaseId",
2572            "name",
2573            "owner",
2574        ];
2575
2576        #[allow(clippy::enum_variant_names)]
2577        enum GeneratedField {
2578            Id,
2579            DatabaseId,
2580            Name,
2581            Owner,
2582        }
2583        impl<'de> serde::Deserialize<'de> for GeneratedField {
2584            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2585            where
2586                D: serde::Deserializer<'de>,
2587            {
2588                struct GeneratedVisitor;
2589
2590                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2591                    type Value = GeneratedField;
2592
2593                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2594                        write!(formatter, "expected one of: {:?}", &FIELDS)
2595                    }
2596
2597                    #[allow(unused_variables)]
2598                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2599                    where
2600                        E: serde::de::Error,
2601                    {
2602                        match value {
2603                            "id" => Ok(GeneratedField::Id),
2604                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2605                            "name" => Ok(GeneratedField::Name),
2606                            "owner" => Ok(GeneratedField::Owner),
2607                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2608                        }
2609                    }
2610                }
2611                deserializer.deserialize_identifier(GeneratedVisitor)
2612            }
2613        }
2614        struct GeneratedVisitor;
2615        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2616            type Value = Schema;
2617
2618            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2619                formatter.write_str("struct catalog.Schema")
2620            }
2621
2622            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Schema, V::Error>
2623                where
2624                    V: serde::de::MapAccess<'de>,
2625            {
2626                let mut id__ = None;
2627                let mut database_id__ = None;
2628                let mut name__ = None;
2629                let mut owner__ = None;
2630                while let Some(k) = map_.next_key()? {
2631                    match k {
2632                        GeneratedField::Id => {
2633                            if id__.is_some() {
2634                                return Err(serde::de::Error::duplicate_field("id"));
2635                            }
2636                            id__ = 
2637                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2638                            ;
2639                        }
2640                        GeneratedField::DatabaseId => {
2641                            if database_id__.is_some() {
2642                                return Err(serde::de::Error::duplicate_field("databaseId"));
2643                            }
2644                            database_id__ = 
2645                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2646                            ;
2647                        }
2648                        GeneratedField::Name => {
2649                            if name__.is_some() {
2650                                return Err(serde::de::Error::duplicate_field("name"));
2651                            }
2652                            name__ = Some(map_.next_value()?);
2653                        }
2654                        GeneratedField::Owner => {
2655                            if owner__.is_some() {
2656                                return Err(serde::de::Error::duplicate_field("owner"));
2657                            }
2658                            owner__ = 
2659                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2660                            ;
2661                        }
2662                    }
2663                }
2664                Ok(Schema {
2665                    id: id__.unwrap_or_default(),
2666                    database_id: database_id__.unwrap_or_default(),
2667                    name: name__.unwrap_or_default(),
2668                    owner: owner__.unwrap_or_default(),
2669                })
2670            }
2671        }
2672        deserializer.deserialize_struct("catalog.Schema", FIELDS, GeneratedVisitor)
2673    }
2674}
2675impl serde::Serialize for SchemaRegistryNameStrategy {
2676    #[allow(deprecated)]
2677    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2678    where
2679        S: serde::Serializer,
2680    {
2681        let variant = match self {
2682            Self::Unspecified => "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
2683            Self::RecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
2684            Self::TopicRecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
2685        };
2686        serializer.serialize_str(variant)
2687    }
2688}
2689impl<'de> serde::Deserialize<'de> for SchemaRegistryNameStrategy {
2690    #[allow(deprecated)]
2691    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2692    where
2693        D: serde::Deserializer<'de>,
2694    {
2695        const FIELDS: &[&str] = &[
2696            "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
2697            "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
2698            "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
2699        ];
2700
2701        struct GeneratedVisitor;
2702
2703        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2704            type Value = SchemaRegistryNameStrategy;
2705
2706            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2707                write!(formatter, "expected one of: {:?}", &FIELDS)
2708            }
2709
2710            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2711            where
2712                E: serde::de::Error,
2713            {
2714                i32::try_from(v)
2715                    .ok()
2716                    .and_then(|x| x.try_into().ok())
2717                    .ok_or_else(|| {
2718                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2719                    })
2720            }
2721
2722            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2723            where
2724                E: serde::de::Error,
2725            {
2726                i32::try_from(v)
2727                    .ok()
2728                    .and_then(|x| x.try_into().ok())
2729                    .ok_or_else(|| {
2730                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2731                    })
2732            }
2733
2734            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2735            where
2736                E: serde::de::Error,
2737            {
2738                match value {
2739                    "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED" => Ok(SchemaRegistryNameStrategy::Unspecified),
2740                    "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::RecordNameStrategy),
2741                    "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::TopicRecordNameStrategy),
2742                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2743                }
2744            }
2745        }
2746        deserializer.deserialize_any(GeneratedVisitor)
2747    }
2748}
2749impl serde::Serialize for Secret {
2750    #[allow(deprecated)]
2751    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2752    where
2753        S: serde::Serializer,
2754    {
2755        use serde::ser::SerializeStruct;
2756        let mut len = 0;
2757        if self.id != 0 {
2758            len += 1;
2759        }
2760        if !self.name.is_empty() {
2761            len += 1;
2762        }
2763        if self.database_id != 0 {
2764            len += 1;
2765        }
2766        if !self.value.is_empty() {
2767            len += 1;
2768        }
2769        if self.owner != 0 {
2770            len += 1;
2771        }
2772        if self.schema_id != 0 {
2773            len += 1;
2774        }
2775        let mut struct_ser = serializer.serialize_struct("catalog.Secret", len)?;
2776        if self.id != 0 {
2777            struct_ser.serialize_field("id", &self.id)?;
2778        }
2779        if !self.name.is_empty() {
2780            struct_ser.serialize_field("name", &self.name)?;
2781        }
2782        if self.database_id != 0 {
2783            struct_ser.serialize_field("databaseId", &self.database_id)?;
2784        }
2785        if !self.value.is_empty() {
2786            #[allow(clippy::needless_borrow)]
2787            #[allow(clippy::needless_borrows_for_generic_args)]
2788            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
2789        }
2790        if self.owner != 0 {
2791            struct_ser.serialize_field("owner", &self.owner)?;
2792        }
2793        if self.schema_id != 0 {
2794            struct_ser.serialize_field("schemaId", &self.schema_id)?;
2795        }
2796        struct_ser.end()
2797    }
2798}
2799impl<'de> serde::Deserialize<'de> for Secret {
2800    #[allow(deprecated)]
2801    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2802    where
2803        D: serde::Deserializer<'de>,
2804    {
2805        const FIELDS: &[&str] = &[
2806            "id",
2807            "name",
2808            "database_id",
2809            "databaseId",
2810            "value",
2811            "owner",
2812            "schema_id",
2813            "schemaId",
2814        ];
2815
2816        #[allow(clippy::enum_variant_names)]
2817        enum GeneratedField {
2818            Id,
2819            Name,
2820            DatabaseId,
2821            Value,
2822            Owner,
2823            SchemaId,
2824        }
2825        impl<'de> serde::Deserialize<'de> for GeneratedField {
2826            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2827            where
2828                D: serde::Deserializer<'de>,
2829            {
2830                struct GeneratedVisitor;
2831
2832                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2833                    type Value = GeneratedField;
2834
2835                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2836                        write!(formatter, "expected one of: {:?}", &FIELDS)
2837                    }
2838
2839                    #[allow(unused_variables)]
2840                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2841                    where
2842                        E: serde::de::Error,
2843                    {
2844                        match value {
2845                            "id" => Ok(GeneratedField::Id),
2846                            "name" => Ok(GeneratedField::Name),
2847                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2848                            "value" => Ok(GeneratedField::Value),
2849                            "owner" => Ok(GeneratedField::Owner),
2850                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2851                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2852                        }
2853                    }
2854                }
2855                deserializer.deserialize_identifier(GeneratedVisitor)
2856            }
2857        }
2858        struct GeneratedVisitor;
2859        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2860            type Value = Secret;
2861
2862            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2863                formatter.write_str("struct catalog.Secret")
2864            }
2865
2866            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Secret, V::Error>
2867                where
2868                    V: serde::de::MapAccess<'de>,
2869            {
2870                let mut id__ = None;
2871                let mut name__ = None;
2872                let mut database_id__ = None;
2873                let mut value__ = None;
2874                let mut owner__ = None;
2875                let mut schema_id__ = None;
2876                while let Some(k) = map_.next_key()? {
2877                    match k {
2878                        GeneratedField::Id => {
2879                            if id__.is_some() {
2880                                return Err(serde::de::Error::duplicate_field("id"));
2881                            }
2882                            id__ = 
2883                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2884                            ;
2885                        }
2886                        GeneratedField::Name => {
2887                            if name__.is_some() {
2888                                return Err(serde::de::Error::duplicate_field("name"));
2889                            }
2890                            name__ = Some(map_.next_value()?);
2891                        }
2892                        GeneratedField::DatabaseId => {
2893                            if database_id__.is_some() {
2894                                return Err(serde::de::Error::duplicate_field("databaseId"));
2895                            }
2896                            database_id__ = 
2897                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2898                            ;
2899                        }
2900                        GeneratedField::Value => {
2901                            if value__.is_some() {
2902                                return Err(serde::de::Error::duplicate_field("value"));
2903                            }
2904                            value__ = 
2905                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2906                            ;
2907                        }
2908                        GeneratedField::Owner => {
2909                            if owner__.is_some() {
2910                                return Err(serde::de::Error::duplicate_field("owner"));
2911                            }
2912                            owner__ = 
2913                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2914                            ;
2915                        }
2916                        GeneratedField::SchemaId => {
2917                            if schema_id__.is_some() {
2918                                return Err(serde::de::Error::duplicate_field("schemaId"));
2919                            }
2920                            schema_id__ = 
2921                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2922                            ;
2923                        }
2924                    }
2925                }
2926                Ok(Secret {
2927                    id: id__.unwrap_or_default(),
2928                    name: name__.unwrap_or_default(),
2929                    database_id: database_id__.unwrap_or_default(),
2930                    value: value__.unwrap_or_default(),
2931                    owner: owner__.unwrap_or_default(),
2932                    schema_id: schema_id__.unwrap_or_default(),
2933                })
2934            }
2935        }
2936        deserializer.deserialize_struct("catalog.Secret", FIELDS, GeneratedVisitor)
2937    }
2938}
2939impl serde::Serialize for Sink {
2940    #[allow(deprecated)]
2941    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2942    where
2943        S: serde::Serializer,
2944    {
2945        use serde::ser::SerializeStruct;
2946        let mut len = 0;
2947        if self.id != 0 {
2948            len += 1;
2949        }
2950        if self.schema_id != 0 {
2951            len += 1;
2952        }
2953        if self.database_id != 0 {
2954            len += 1;
2955        }
2956        if !self.name.is_empty() {
2957            len += 1;
2958        }
2959        if !self.columns.is_empty() {
2960            len += 1;
2961        }
2962        if !self.plan_pk.is_empty() {
2963            len += 1;
2964        }
2965        if !self.distribution_key.is_empty() {
2966            len += 1;
2967        }
2968        if !self.downstream_pk.is_empty() {
2969            len += 1;
2970        }
2971        if self.sink_type != 0 {
2972            len += 1;
2973        }
2974        if self.owner != 0 {
2975            len += 1;
2976        }
2977        if !self.properties.is_empty() {
2978            len += 1;
2979        }
2980        if !self.definition.is_empty() {
2981            len += 1;
2982        }
2983        if self.connection_id.is_some() {
2984            len += 1;
2985        }
2986        if self.initialized_at_epoch.is_some() {
2987            len += 1;
2988        }
2989        if self.created_at_epoch.is_some() {
2990            len += 1;
2991        }
2992        if !self.db_name.is_empty() {
2993            len += 1;
2994        }
2995        if !self.sink_from_name.is_empty() {
2996            len += 1;
2997        }
2998        if self.stream_job_status != 0 {
2999            len += 1;
3000        }
3001        if self.format_desc.is_some() {
3002            len += 1;
3003        }
3004        if self.target_table.is_some() {
3005            len += 1;
3006        }
3007        if self.initialized_at_cluster_version.is_some() {
3008            len += 1;
3009        }
3010        if self.created_at_cluster_version.is_some() {
3011            len += 1;
3012        }
3013        if self.create_type != 0 {
3014            len += 1;
3015        }
3016        if !self.secret_refs.is_empty() {
3017            len += 1;
3018        }
3019        if !self.original_target_columns.is_empty() {
3020            len += 1;
3021        }
3022        let mut struct_ser = serializer.serialize_struct("catalog.Sink", len)?;
3023        if self.id != 0 {
3024            struct_ser.serialize_field("id", &self.id)?;
3025        }
3026        if self.schema_id != 0 {
3027            struct_ser.serialize_field("schemaId", &self.schema_id)?;
3028        }
3029        if self.database_id != 0 {
3030            struct_ser.serialize_field("databaseId", &self.database_id)?;
3031        }
3032        if !self.name.is_empty() {
3033            struct_ser.serialize_field("name", &self.name)?;
3034        }
3035        if !self.columns.is_empty() {
3036            struct_ser.serialize_field("columns", &self.columns)?;
3037        }
3038        if !self.plan_pk.is_empty() {
3039            struct_ser.serialize_field("planPk", &self.plan_pk)?;
3040        }
3041        if !self.distribution_key.is_empty() {
3042            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
3043        }
3044        if !self.downstream_pk.is_empty() {
3045            struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
3046        }
3047        if self.sink_type != 0 {
3048            let v = SinkType::try_from(self.sink_type)
3049                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
3050            struct_ser.serialize_field("sinkType", &v)?;
3051        }
3052        if self.owner != 0 {
3053            struct_ser.serialize_field("owner", &self.owner)?;
3054        }
3055        if !self.properties.is_empty() {
3056            struct_ser.serialize_field("properties", &self.properties)?;
3057        }
3058        if !self.definition.is_empty() {
3059            struct_ser.serialize_field("definition", &self.definition)?;
3060        }
3061        if let Some(v) = self.connection_id.as_ref() {
3062            struct_ser.serialize_field("connectionId", v)?;
3063        }
3064        if let Some(v) = self.initialized_at_epoch.as_ref() {
3065            #[allow(clippy::needless_borrow)]
3066            #[allow(clippy::needless_borrows_for_generic_args)]
3067            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3068        }
3069        if let Some(v) = self.created_at_epoch.as_ref() {
3070            #[allow(clippy::needless_borrow)]
3071            #[allow(clippy::needless_borrows_for_generic_args)]
3072            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3073        }
3074        if !self.db_name.is_empty() {
3075            struct_ser.serialize_field("dbName", &self.db_name)?;
3076        }
3077        if !self.sink_from_name.is_empty() {
3078            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
3079        }
3080        if self.stream_job_status != 0 {
3081            let v = StreamJobStatus::try_from(self.stream_job_status)
3082                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
3083            struct_ser.serialize_field("streamJobStatus", &v)?;
3084        }
3085        if let Some(v) = self.format_desc.as_ref() {
3086            struct_ser.serialize_field("formatDesc", v)?;
3087        }
3088        if let Some(v) = self.target_table.as_ref() {
3089            struct_ser.serialize_field("targetTable", v)?;
3090        }
3091        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3092            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3093        }
3094        if let Some(v) = self.created_at_cluster_version.as_ref() {
3095            struct_ser.serialize_field("createdAtClusterVersion", v)?;
3096        }
3097        if self.create_type != 0 {
3098            let v = CreateType::try_from(self.create_type)
3099                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
3100            struct_ser.serialize_field("createType", &v)?;
3101        }
3102        if !self.secret_refs.is_empty() {
3103            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3104        }
3105        if !self.original_target_columns.is_empty() {
3106            struct_ser.serialize_field("originalTargetColumns", &self.original_target_columns)?;
3107        }
3108        struct_ser.end()
3109    }
3110}
3111impl<'de> serde::Deserialize<'de> for Sink {
3112    #[allow(deprecated)]
3113    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3114    where
3115        D: serde::Deserializer<'de>,
3116    {
3117        const FIELDS: &[&str] = &[
3118            "id",
3119            "schema_id",
3120            "schemaId",
3121            "database_id",
3122            "databaseId",
3123            "name",
3124            "columns",
3125            "plan_pk",
3126            "planPk",
3127            "distribution_key",
3128            "distributionKey",
3129            "downstream_pk",
3130            "downstreamPk",
3131            "sink_type",
3132            "sinkType",
3133            "owner",
3134            "properties",
3135            "definition",
3136            "connection_id",
3137            "connectionId",
3138            "initialized_at_epoch",
3139            "initializedAtEpoch",
3140            "created_at_epoch",
3141            "createdAtEpoch",
3142            "db_name",
3143            "dbName",
3144            "sink_from_name",
3145            "sinkFromName",
3146            "stream_job_status",
3147            "streamJobStatus",
3148            "format_desc",
3149            "formatDesc",
3150            "target_table",
3151            "targetTable",
3152            "initialized_at_cluster_version",
3153            "initializedAtClusterVersion",
3154            "created_at_cluster_version",
3155            "createdAtClusterVersion",
3156            "create_type",
3157            "createType",
3158            "secret_refs",
3159            "secretRefs",
3160            "original_target_columns",
3161            "originalTargetColumns",
3162        ];
3163
3164        #[allow(clippy::enum_variant_names)]
3165        enum GeneratedField {
3166            Id,
3167            SchemaId,
3168            DatabaseId,
3169            Name,
3170            Columns,
3171            PlanPk,
3172            DistributionKey,
3173            DownstreamPk,
3174            SinkType,
3175            Owner,
3176            Properties,
3177            Definition,
3178            ConnectionId,
3179            InitializedAtEpoch,
3180            CreatedAtEpoch,
3181            DbName,
3182            SinkFromName,
3183            StreamJobStatus,
3184            FormatDesc,
3185            TargetTable,
3186            InitializedAtClusterVersion,
3187            CreatedAtClusterVersion,
3188            CreateType,
3189            SecretRefs,
3190            OriginalTargetColumns,
3191        }
3192        impl<'de> serde::Deserialize<'de> for GeneratedField {
3193            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3194            where
3195                D: serde::Deserializer<'de>,
3196            {
3197                struct GeneratedVisitor;
3198
3199                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3200                    type Value = GeneratedField;
3201
3202                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3203                        write!(formatter, "expected one of: {:?}", &FIELDS)
3204                    }
3205
3206                    #[allow(unused_variables)]
3207                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3208                    where
3209                        E: serde::de::Error,
3210                    {
3211                        match value {
3212                            "id" => Ok(GeneratedField::Id),
3213                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3214                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3215                            "name" => Ok(GeneratedField::Name),
3216                            "columns" => Ok(GeneratedField::Columns),
3217                            "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
3218                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
3219                            "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
3220                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
3221                            "owner" => Ok(GeneratedField::Owner),
3222                            "properties" => Ok(GeneratedField::Properties),
3223                            "definition" => Ok(GeneratedField::Definition),
3224                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3225                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
3226                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
3227                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
3228                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
3229                            "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
3230                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
3231                            "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
3232                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
3233                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
3234                            "createType" | "create_type" => Ok(GeneratedField::CreateType),
3235                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3236                            "originalTargetColumns" | "original_target_columns" => Ok(GeneratedField::OriginalTargetColumns),
3237                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3238                        }
3239                    }
3240                }
3241                deserializer.deserialize_identifier(GeneratedVisitor)
3242            }
3243        }
3244        struct GeneratedVisitor;
3245        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3246            type Value = Sink;
3247
3248            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3249                formatter.write_str("struct catalog.Sink")
3250            }
3251
3252            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Sink, V::Error>
3253                where
3254                    V: serde::de::MapAccess<'de>,
3255            {
3256                let mut id__ = None;
3257                let mut schema_id__ = None;
3258                let mut database_id__ = None;
3259                let mut name__ = None;
3260                let mut columns__ = None;
3261                let mut plan_pk__ = None;
3262                let mut distribution_key__ = None;
3263                let mut downstream_pk__ = None;
3264                let mut sink_type__ = None;
3265                let mut owner__ = None;
3266                let mut properties__ = None;
3267                let mut definition__ = None;
3268                let mut connection_id__ = None;
3269                let mut initialized_at_epoch__ = None;
3270                let mut created_at_epoch__ = None;
3271                let mut db_name__ = None;
3272                let mut sink_from_name__ = None;
3273                let mut stream_job_status__ = None;
3274                let mut format_desc__ = None;
3275                let mut target_table__ = None;
3276                let mut initialized_at_cluster_version__ = None;
3277                let mut created_at_cluster_version__ = None;
3278                let mut create_type__ = None;
3279                let mut secret_refs__ = None;
3280                let mut original_target_columns__ = None;
3281                while let Some(k) = map_.next_key()? {
3282                    match k {
3283                        GeneratedField::Id => {
3284                            if id__.is_some() {
3285                                return Err(serde::de::Error::duplicate_field("id"));
3286                            }
3287                            id__ = 
3288                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3289                            ;
3290                        }
3291                        GeneratedField::SchemaId => {
3292                            if schema_id__.is_some() {
3293                                return Err(serde::de::Error::duplicate_field("schemaId"));
3294                            }
3295                            schema_id__ = 
3296                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3297                            ;
3298                        }
3299                        GeneratedField::DatabaseId => {
3300                            if database_id__.is_some() {
3301                                return Err(serde::de::Error::duplicate_field("databaseId"));
3302                            }
3303                            database_id__ = 
3304                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3305                            ;
3306                        }
3307                        GeneratedField::Name => {
3308                            if name__.is_some() {
3309                                return Err(serde::de::Error::duplicate_field("name"));
3310                            }
3311                            name__ = Some(map_.next_value()?);
3312                        }
3313                        GeneratedField::Columns => {
3314                            if columns__.is_some() {
3315                                return Err(serde::de::Error::duplicate_field("columns"));
3316                            }
3317                            columns__ = Some(map_.next_value()?);
3318                        }
3319                        GeneratedField::PlanPk => {
3320                            if plan_pk__.is_some() {
3321                                return Err(serde::de::Error::duplicate_field("planPk"));
3322                            }
3323                            plan_pk__ = Some(map_.next_value()?);
3324                        }
3325                        GeneratedField::DistributionKey => {
3326                            if distribution_key__.is_some() {
3327                                return Err(serde::de::Error::duplicate_field("distributionKey"));
3328                            }
3329                            distribution_key__ = 
3330                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3331                                    .into_iter().map(|x| x.0).collect())
3332                            ;
3333                        }
3334                        GeneratedField::DownstreamPk => {
3335                            if downstream_pk__.is_some() {
3336                                return Err(serde::de::Error::duplicate_field("downstreamPk"));
3337                            }
3338                            downstream_pk__ = 
3339                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3340                                    .into_iter().map(|x| x.0).collect())
3341                            ;
3342                        }
3343                        GeneratedField::SinkType => {
3344                            if sink_type__.is_some() {
3345                                return Err(serde::de::Error::duplicate_field("sinkType"));
3346                            }
3347                            sink_type__ = Some(map_.next_value::<SinkType>()? as i32);
3348                        }
3349                        GeneratedField::Owner => {
3350                            if owner__.is_some() {
3351                                return Err(serde::de::Error::duplicate_field("owner"));
3352                            }
3353                            owner__ = 
3354                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3355                            ;
3356                        }
3357                        GeneratedField::Properties => {
3358                            if properties__.is_some() {
3359                                return Err(serde::de::Error::duplicate_field("properties"));
3360                            }
3361                            properties__ = Some(
3362                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3363                            );
3364                        }
3365                        GeneratedField::Definition => {
3366                            if definition__.is_some() {
3367                                return Err(serde::de::Error::duplicate_field("definition"));
3368                            }
3369                            definition__ = Some(map_.next_value()?);
3370                        }
3371                        GeneratedField::ConnectionId => {
3372                            if connection_id__.is_some() {
3373                                return Err(serde::de::Error::duplicate_field("connectionId"));
3374                            }
3375                            connection_id__ = 
3376                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3377                            ;
3378                        }
3379                        GeneratedField::InitializedAtEpoch => {
3380                            if initialized_at_epoch__.is_some() {
3381                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
3382                            }
3383                            initialized_at_epoch__ = 
3384                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3385                            ;
3386                        }
3387                        GeneratedField::CreatedAtEpoch => {
3388                            if created_at_epoch__.is_some() {
3389                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
3390                            }
3391                            created_at_epoch__ = 
3392                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3393                            ;
3394                        }
3395                        GeneratedField::DbName => {
3396                            if db_name__.is_some() {
3397                                return Err(serde::de::Error::duplicate_field("dbName"));
3398                            }
3399                            db_name__ = Some(map_.next_value()?);
3400                        }
3401                        GeneratedField::SinkFromName => {
3402                            if sink_from_name__.is_some() {
3403                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
3404                            }
3405                            sink_from_name__ = Some(map_.next_value()?);
3406                        }
3407                        GeneratedField::StreamJobStatus => {
3408                            if stream_job_status__.is_some() {
3409                                return Err(serde::de::Error::duplicate_field("streamJobStatus"));
3410                            }
3411                            stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
3412                        }
3413                        GeneratedField::FormatDesc => {
3414                            if format_desc__.is_some() {
3415                                return Err(serde::de::Error::duplicate_field("formatDesc"));
3416                            }
3417                            format_desc__ = map_.next_value()?;
3418                        }
3419                        GeneratedField::TargetTable => {
3420                            if target_table__.is_some() {
3421                                return Err(serde::de::Error::duplicate_field("targetTable"));
3422                            }
3423                            target_table__ = 
3424                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3425                            ;
3426                        }
3427                        GeneratedField::InitializedAtClusterVersion => {
3428                            if initialized_at_cluster_version__.is_some() {
3429                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
3430                            }
3431                            initialized_at_cluster_version__ = map_.next_value()?;
3432                        }
3433                        GeneratedField::CreatedAtClusterVersion => {
3434                            if created_at_cluster_version__.is_some() {
3435                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
3436                            }
3437                            created_at_cluster_version__ = map_.next_value()?;
3438                        }
3439                        GeneratedField::CreateType => {
3440                            if create_type__.is_some() {
3441                                return Err(serde::de::Error::duplicate_field("createType"));
3442                            }
3443                            create_type__ = Some(map_.next_value::<CreateType>()? as i32);
3444                        }
3445                        GeneratedField::SecretRefs => {
3446                            if secret_refs__.is_some() {
3447                                return Err(serde::de::Error::duplicate_field("secretRefs"));
3448                            }
3449                            secret_refs__ = Some(
3450                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3451                            );
3452                        }
3453                        GeneratedField::OriginalTargetColumns => {
3454                            if original_target_columns__.is_some() {
3455                                return Err(serde::de::Error::duplicate_field("originalTargetColumns"));
3456                            }
3457                            original_target_columns__ = Some(map_.next_value()?);
3458                        }
3459                    }
3460                }
3461                Ok(Sink {
3462                    id: id__.unwrap_or_default(),
3463                    schema_id: schema_id__.unwrap_or_default(),
3464                    database_id: database_id__.unwrap_or_default(),
3465                    name: name__.unwrap_or_default(),
3466                    columns: columns__.unwrap_or_default(),
3467                    plan_pk: plan_pk__.unwrap_or_default(),
3468                    distribution_key: distribution_key__.unwrap_or_default(),
3469                    downstream_pk: downstream_pk__.unwrap_or_default(),
3470                    sink_type: sink_type__.unwrap_or_default(),
3471                    owner: owner__.unwrap_or_default(),
3472                    properties: properties__.unwrap_or_default(),
3473                    definition: definition__.unwrap_or_default(),
3474                    connection_id: connection_id__,
3475                    initialized_at_epoch: initialized_at_epoch__,
3476                    created_at_epoch: created_at_epoch__,
3477                    db_name: db_name__.unwrap_or_default(),
3478                    sink_from_name: sink_from_name__.unwrap_or_default(),
3479                    stream_job_status: stream_job_status__.unwrap_or_default(),
3480                    format_desc: format_desc__,
3481                    target_table: target_table__,
3482                    initialized_at_cluster_version: initialized_at_cluster_version__,
3483                    created_at_cluster_version: created_at_cluster_version__,
3484                    create_type: create_type__.unwrap_or_default(),
3485                    secret_refs: secret_refs__.unwrap_or_default(),
3486                    original_target_columns: original_target_columns__.unwrap_or_default(),
3487                })
3488            }
3489        }
3490        deserializer.deserialize_struct("catalog.Sink", FIELDS, GeneratedVisitor)
3491    }
3492}
3493impl serde::Serialize for SinkFormatDesc {
3494    #[allow(deprecated)]
3495    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3496    where
3497        S: serde::Serializer,
3498    {
3499        use serde::ser::SerializeStruct;
3500        let mut len = 0;
3501        if self.format != 0 {
3502            len += 1;
3503        }
3504        if self.encode != 0 {
3505            len += 1;
3506        }
3507        if !self.options.is_empty() {
3508            len += 1;
3509        }
3510        if self.key_encode.is_some() {
3511            len += 1;
3512        }
3513        if !self.secret_refs.is_empty() {
3514            len += 1;
3515        }
3516        if self.connection_id.is_some() {
3517            len += 1;
3518        }
3519        let mut struct_ser = serializer.serialize_struct("catalog.SinkFormatDesc", len)?;
3520        if self.format != 0 {
3521            let v = super::plan_common::FormatType::try_from(self.format)
3522                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
3523            struct_ser.serialize_field("format", &v)?;
3524        }
3525        if self.encode != 0 {
3526            let v = super::plan_common::EncodeType::try_from(self.encode)
3527                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encode)))?;
3528            struct_ser.serialize_field("encode", &v)?;
3529        }
3530        if !self.options.is_empty() {
3531            struct_ser.serialize_field("options", &self.options)?;
3532        }
3533        if let Some(v) = self.key_encode.as_ref() {
3534            let v = super::plan_common::EncodeType::try_from(*v)
3535                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
3536            struct_ser.serialize_field("keyEncode", &v)?;
3537        }
3538        if !self.secret_refs.is_empty() {
3539            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3540        }
3541        if let Some(v) = self.connection_id.as_ref() {
3542            struct_ser.serialize_field("connectionId", v)?;
3543        }
3544        struct_ser.end()
3545    }
3546}
3547impl<'de> serde::Deserialize<'de> for SinkFormatDesc {
3548    #[allow(deprecated)]
3549    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3550    where
3551        D: serde::Deserializer<'de>,
3552    {
3553        const FIELDS: &[&str] = &[
3554            "format",
3555            "encode",
3556            "options",
3557            "key_encode",
3558            "keyEncode",
3559            "secret_refs",
3560            "secretRefs",
3561            "connection_id",
3562            "connectionId",
3563        ];
3564
3565        #[allow(clippy::enum_variant_names)]
3566        enum GeneratedField {
3567            Format,
3568            Encode,
3569            Options,
3570            KeyEncode,
3571            SecretRefs,
3572            ConnectionId,
3573        }
3574        impl<'de> serde::Deserialize<'de> for GeneratedField {
3575            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3576            where
3577                D: serde::Deserializer<'de>,
3578            {
3579                struct GeneratedVisitor;
3580
3581                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3582                    type Value = GeneratedField;
3583
3584                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3585                        write!(formatter, "expected one of: {:?}", &FIELDS)
3586                    }
3587
3588                    #[allow(unused_variables)]
3589                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3590                    where
3591                        E: serde::de::Error,
3592                    {
3593                        match value {
3594                            "format" => Ok(GeneratedField::Format),
3595                            "encode" => Ok(GeneratedField::Encode),
3596                            "options" => Ok(GeneratedField::Options),
3597                            "keyEncode" | "key_encode" => Ok(GeneratedField::KeyEncode),
3598                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3599                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3600                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3601                        }
3602                    }
3603                }
3604                deserializer.deserialize_identifier(GeneratedVisitor)
3605            }
3606        }
3607        struct GeneratedVisitor;
3608        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3609            type Value = SinkFormatDesc;
3610
3611            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3612                formatter.write_str("struct catalog.SinkFormatDesc")
3613            }
3614
3615            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkFormatDesc, V::Error>
3616                where
3617                    V: serde::de::MapAccess<'de>,
3618            {
3619                let mut format__ = None;
3620                let mut encode__ = None;
3621                let mut options__ = None;
3622                let mut key_encode__ = None;
3623                let mut secret_refs__ = None;
3624                let mut connection_id__ = None;
3625                while let Some(k) = map_.next_key()? {
3626                    match k {
3627                        GeneratedField::Format => {
3628                            if format__.is_some() {
3629                                return Err(serde::de::Error::duplicate_field("format"));
3630                            }
3631                            format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
3632                        }
3633                        GeneratedField::Encode => {
3634                            if encode__.is_some() {
3635                                return Err(serde::de::Error::duplicate_field("encode"));
3636                            }
3637                            encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
3638                        }
3639                        GeneratedField::Options => {
3640                            if options__.is_some() {
3641                                return Err(serde::de::Error::duplicate_field("options"));
3642                            }
3643                            options__ = Some(
3644                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3645                            );
3646                        }
3647                        GeneratedField::KeyEncode => {
3648                            if key_encode__.is_some() {
3649                                return Err(serde::de::Error::duplicate_field("keyEncode"));
3650                            }
3651                            key_encode__ = map_.next_value::<::std::option::Option<super::plan_common::EncodeType>>()?.map(|x| x as i32);
3652                        }
3653                        GeneratedField::SecretRefs => {
3654                            if secret_refs__.is_some() {
3655                                return Err(serde::de::Error::duplicate_field("secretRefs"));
3656                            }
3657                            secret_refs__ = Some(
3658                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3659                            );
3660                        }
3661                        GeneratedField::ConnectionId => {
3662                            if connection_id__.is_some() {
3663                                return Err(serde::de::Error::duplicate_field("connectionId"));
3664                            }
3665                            connection_id__ = 
3666                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3667                            ;
3668                        }
3669                    }
3670                }
3671                Ok(SinkFormatDesc {
3672                    format: format__.unwrap_or_default(),
3673                    encode: encode__.unwrap_or_default(),
3674                    options: options__.unwrap_or_default(),
3675                    key_encode: key_encode__,
3676                    secret_refs: secret_refs__.unwrap_or_default(),
3677                    connection_id: connection_id__,
3678                })
3679            }
3680        }
3681        deserializer.deserialize_struct("catalog.SinkFormatDesc", FIELDS, GeneratedVisitor)
3682    }
3683}
3684impl serde::Serialize for SinkType {
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        let variant = match self {
3691            Self::Unspecified => "SINK_TYPE_UNSPECIFIED",
3692            Self::AppendOnly => "SINK_TYPE_APPEND_ONLY",
3693            Self::ForceAppendOnly => "SINK_TYPE_FORCE_APPEND_ONLY",
3694            Self::Upsert => "SINK_TYPE_UPSERT",
3695        };
3696        serializer.serialize_str(variant)
3697    }
3698}
3699impl<'de> serde::Deserialize<'de> for SinkType {
3700    #[allow(deprecated)]
3701    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3702    where
3703        D: serde::Deserializer<'de>,
3704    {
3705        const FIELDS: &[&str] = &[
3706            "SINK_TYPE_UNSPECIFIED",
3707            "SINK_TYPE_APPEND_ONLY",
3708            "SINK_TYPE_FORCE_APPEND_ONLY",
3709            "SINK_TYPE_UPSERT",
3710        ];
3711
3712        struct GeneratedVisitor;
3713
3714        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3715            type Value = SinkType;
3716
3717            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3718                write!(formatter, "expected one of: {:?}", &FIELDS)
3719            }
3720
3721            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3722            where
3723                E: serde::de::Error,
3724            {
3725                i32::try_from(v)
3726                    .ok()
3727                    .and_then(|x| x.try_into().ok())
3728                    .ok_or_else(|| {
3729                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3730                    })
3731            }
3732
3733            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3734            where
3735                E: serde::de::Error,
3736            {
3737                i32::try_from(v)
3738                    .ok()
3739                    .and_then(|x| x.try_into().ok())
3740                    .ok_or_else(|| {
3741                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3742                    })
3743            }
3744
3745            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3746            where
3747                E: serde::de::Error,
3748            {
3749                match value {
3750                    "SINK_TYPE_UNSPECIFIED" => Ok(SinkType::Unspecified),
3751                    "SINK_TYPE_APPEND_ONLY" => Ok(SinkType::AppendOnly),
3752                    "SINK_TYPE_FORCE_APPEND_ONLY" => Ok(SinkType::ForceAppendOnly),
3753                    "SINK_TYPE_UPSERT" => Ok(SinkType::Upsert),
3754                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3755                }
3756            }
3757        }
3758        deserializer.deserialize_any(GeneratedVisitor)
3759    }
3760}
3761impl serde::Serialize for Source {
3762    #[allow(deprecated)]
3763    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3764    where
3765        S: serde::Serializer,
3766    {
3767        use serde::ser::SerializeStruct;
3768        let mut len = 0;
3769        if self.id != 0 {
3770            len += 1;
3771        }
3772        if self.schema_id != 0 {
3773            len += 1;
3774        }
3775        if self.database_id != 0 {
3776            len += 1;
3777        }
3778        if !self.name.is_empty() {
3779            len += 1;
3780        }
3781        if self.row_id_index.is_some() {
3782            len += 1;
3783        }
3784        if !self.columns.is_empty() {
3785            len += 1;
3786        }
3787        if !self.pk_column_ids.is_empty() {
3788            len += 1;
3789        }
3790        if !self.with_properties.is_empty() {
3791            len += 1;
3792        }
3793        if self.owner != 0 {
3794            len += 1;
3795        }
3796        if self.info.is_some() {
3797            len += 1;
3798        }
3799        if !self.watermark_descs.is_empty() {
3800            len += 1;
3801        }
3802        if !self.definition.is_empty() {
3803            len += 1;
3804        }
3805        if self.connection_id.is_some() {
3806            len += 1;
3807        }
3808        if self.initialized_at_epoch.is_some() {
3809            len += 1;
3810        }
3811        if self.created_at_epoch.is_some() {
3812            len += 1;
3813        }
3814        if self.initialized_at_cluster_version.is_some() {
3815            len += 1;
3816        }
3817        if self.created_at_cluster_version.is_some() {
3818            len += 1;
3819        }
3820        if !self.secret_refs.is_empty() {
3821            len += 1;
3822        }
3823        if self.version != 0 {
3824            len += 1;
3825        }
3826        if self.rate_limit.is_some() {
3827            len += 1;
3828        }
3829        if self.optional_associated_table_id.is_some() {
3830            len += 1;
3831        }
3832        let mut struct_ser = serializer.serialize_struct("catalog.Source", len)?;
3833        if self.id != 0 {
3834            struct_ser.serialize_field("id", &self.id)?;
3835        }
3836        if self.schema_id != 0 {
3837            struct_ser.serialize_field("schemaId", &self.schema_id)?;
3838        }
3839        if self.database_id != 0 {
3840            struct_ser.serialize_field("databaseId", &self.database_id)?;
3841        }
3842        if !self.name.is_empty() {
3843            struct_ser.serialize_field("name", &self.name)?;
3844        }
3845        if let Some(v) = self.row_id_index.as_ref() {
3846            struct_ser.serialize_field("rowIdIndex", v)?;
3847        }
3848        if !self.columns.is_empty() {
3849            struct_ser.serialize_field("columns", &self.columns)?;
3850        }
3851        if !self.pk_column_ids.is_empty() {
3852            struct_ser.serialize_field("pkColumnIds", &self.pk_column_ids)?;
3853        }
3854        if !self.with_properties.is_empty() {
3855            struct_ser.serialize_field("withProperties", &self.with_properties)?;
3856        }
3857        if self.owner != 0 {
3858            struct_ser.serialize_field("owner", &self.owner)?;
3859        }
3860        if let Some(v) = self.info.as_ref() {
3861            struct_ser.serialize_field("info", v)?;
3862        }
3863        if !self.watermark_descs.is_empty() {
3864            struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
3865        }
3866        if !self.definition.is_empty() {
3867            struct_ser.serialize_field("definition", &self.definition)?;
3868        }
3869        if let Some(v) = self.connection_id.as_ref() {
3870            struct_ser.serialize_field("connectionId", v)?;
3871        }
3872        if let Some(v) = self.initialized_at_epoch.as_ref() {
3873            #[allow(clippy::needless_borrow)]
3874            #[allow(clippy::needless_borrows_for_generic_args)]
3875            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3876        }
3877        if let Some(v) = self.created_at_epoch.as_ref() {
3878            #[allow(clippy::needless_borrow)]
3879            #[allow(clippy::needless_borrows_for_generic_args)]
3880            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3881        }
3882        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3883            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3884        }
3885        if let Some(v) = self.created_at_cluster_version.as_ref() {
3886            struct_ser.serialize_field("createdAtClusterVersion", v)?;
3887        }
3888        if !self.secret_refs.is_empty() {
3889            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3890        }
3891        if self.version != 0 {
3892            #[allow(clippy::needless_borrow)]
3893            #[allow(clippy::needless_borrows_for_generic_args)]
3894            struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
3895        }
3896        if let Some(v) = self.rate_limit.as_ref() {
3897            struct_ser.serialize_field("rateLimit", v)?;
3898        }
3899        if let Some(v) = self.optional_associated_table_id.as_ref() {
3900            match v {
3901                source::OptionalAssociatedTableId::AssociatedTableId(v) => {
3902                    struct_ser.serialize_field("associatedTableId", v)?;
3903                }
3904            }
3905        }
3906        struct_ser.end()
3907    }
3908}
3909impl<'de> serde::Deserialize<'de> for Source {
3910    #[allow(deprecated)]
3911    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3912    where
3913        D: serde::Deserializer<'de>,
3914    {
3915        const FIELDS: &[&str] = &[
3916            "id",
3917            "schema_id",
3918            "schemaId",
3919            "database_id",
3920            "databaseId",
3921            "name",
3922            "row_id_index",
3923            "rowIdIndex",
3924            "columns",
3925            "pk_column_ids",
3926            "pkColumnIds",
3927            "with_properties",
3928            "withProperties",
3929            "owner",
3930            "info",
3931            "watermark_descs",
3932            "watermarkDescs",
3933            "definition",
3934            "connection_id",
3935            "connectionId",
3936            "initialized_at_epoch",
3937            "initializedAtEpoch",
3938            "created_at_epoch",
3939            "createdAtEpoch",
3940            "initialized_at_cluster_version",
3941            "initializedAtClusterVersion",
3942            "created_at_cluster_version",
3943            "createdAtClusterVersion",
3944            "secret_refs",
3945            "secretRefs",
3946            "version",
3947            "rate_limit",
3948            "rateLimit",
3949            "associated_table_id",
3950            "associatedTableId",
3951        ];
3952
3953        #[allow(clippy::enum_variant_names)]
3954        enum GeneratedField {
3955            Id,
3956            SchemaId,
3957            DatabaseId,
3958            Name,
3959            RowIdIndex,
3960            Columns,
3961            PkColumnIds,
3962            WithProperties,
3963            Owner,
3964            Info,
3965            WatermarkDescs,
3966            Definition,
3967            ConnectionId,
3968            InitializedAtEpoch,
3969            CreatedAtEpoch,
3970            InitializedAtClusterVersion,
3971            CreatedAtClusterVersion,
3972            SecretRefs,
3973            Version,
3974            RateLimit,
3975            AssociatedTableId,
3976        }
3977        impl<'de> serde::Deserialize<'de> for GeneratedField {
3978            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3979            where
3980                D: serde::Deserializer<'de>,
3981            {
3982                struct GeneratedVisitor;
3983
3984                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3985                    type Value = GeneratedField;
3986
3987                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3988                        write!(formatter, "expected one of: {:?}", &FIELDS)
3989                    }
3990
3991                    #[allow(unused_variables)]
3992                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3993                    where
3994                        E: serde::de::Error,
3995                    {
3996                        match value {
3997                            "id" => Ok(GeneratedField::Id),
3998                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3999                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4000                            "name" => Ok(GeneratedField::Name),
4001                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
4002                            "columns" => Ok(GeneratedField::Columns),
4003                            "pkColumnIds" | "pk_column_ids" => Ok(GeneratedField::PkColumnIds),
4004                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
4005                            "owner" => Ok(GeneratedField::Owner),
4006                            "info" => Ok(GeneratedField::Info),
4007                            "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
4008                            "definition" => Ok(GeneratedField::Definition),
4009                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4010                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4011                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4012                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4013                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4014                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
4015                            "version" => Ok(GeneratedField::Version),
4016                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4017                            "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
4018                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4019                        }
4020                    }
4021                }
4022                deserializer.deserialize_identifier(GeneratedVisitor)
4023            }
4024        }
4025        struct GeneratedVisitor;
4026        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4027            type Value = Source;
4028
4029            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4030                formatter.write_str("struct catalog.Source")
4031            }
4032
4033            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Source, V::Error>
4034                where
4035                    V: serde::de::MapAccess<'de>,
4036            {
4037                let mut id__ = None;
4038                let mut schema_id__ = None;
4039                let mut database_id__ = None;
4040                let mut name__ = None;
4041                let mut row_id_index__ = None;
4042                let mut columns__ = None;
4043                let mut pk_column_ids__ = None;
4044                let mut with_properties__ = None;
4045                let mut owner__ = None;
4046                let mut info__ = None;
4047                let mut watermark_descs__ = None;
4048                let mut definition__ = None;
4049                let mut connection_id__ = None;
4050                let mut initialized_at_epoch__ = None;
4051                let mut created_at_epoch__ = None;
4052                let mut initialized_at_cluster_version__ = None;
4053                let mut created_at_cluster_version__ = None;
4054                let mut secret_refs__ = None;
4055                let mut version__ = None;
4056                let mut rate_limit__ = None;
4057                let mut optional_associated_table_id__ = None;
4058                while let Some(k) = map_.next_key()? {
4059                    match k {
4060                        GeneratedField::Id => {
4061                            if id__.is_some() {
4062                                return Err(serde::de::Error::duplicate_field("id"));
4063                            }
4064                            id__ = 
4065                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4066                            ;
4067                        }
4068                        GeneratedField::SchemaId => {
4069                            if schema_id__.is_some() {
4070                                return Err(serde::de::Error::duplicate_field("schemaId"));
4071                            }
4072                            schema_id__ = 
4073                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4074                            ;
4075                        }
4076                        GeneratedField::DatabaseId => {
4077                            if database_id__.is_some() {
4078                                return Err(serde::de::Error::duplicate_field("databaseId"));
4079                            }
4080                            database_id__ = 
4081                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4082                            ;
4083                        }
4084                        GeneratedField::Name => {
4085                            if name__.is_some() {
4086                                return Err(serde::de::Error::duplicate_field("name"));
4087                            }
4088                            name__ = Some(map_.next_value()?);
4089                        }
4090                        GeneratedField::RowIdIndex => {
4091                            if row_id_index__.is_some() {
4092                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
4093                            }
4094                            row_id_index__ = 
4095                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4096                            ;
4097                        }
4098                        GeneratedField::Columns => {
4099                            if columns__.is_some() {
4100                                return Err(serde::de::Error::duplicate_field("columns"));
4101                            }
4102                            columns__ = Some(map_.next_value()?);
4103                        }
4104                        GeneratedField::PkColumnIds => {
4105                            if pk_column_ids__.is_some() {
4106                                return Err(serde::de::Error::duplicate_field("pkColumnIds"));
4107                            }
4108                            pk_column_ids__ = 
4109                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4110                                    .into_iter().map(|x| x.0).collect())
4111                            ;
4112                        }
4113                        GeneratedField::WithProperties => {
4114                            if with_properties__.is_some() {
4115                                return Err(serde::de::Error::duplicate_field("withProperties"));
4116                            }
4117                            with_properties__ = Some(
4118                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4119                            );
4120                        }
4121                        GeneratedField::Owner => {
4122                            if owner__.is_some() {
4123                                return Err(serde::de::Error::duplicate_field("owner"));
4124                            }
4125                            owner__ = 
4126                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4127                            ;
4128                        }
4129                        GeneratedField::Info => {
4130                            if info__.is_some() {
4131                                return Err(serde::de::Error::duplicate_field("info"));
4132                            }
4133                            info__ = map_.next_value()?;
4134                        }
4135                        GeneratedField::WatermarkDescs => {
4136                            if watermark_descs__.is_some() {
4137                                return Err(serde::de::Error::duplicate_field("watermarkDescs"));
4138                            }
4139                            watermark_descs__ = Some(map_.next_value()?);
4140                        }
4141                        GeneratedField::Definition => {
4142                            if definition__.is_some() {
4143                                return Err(serde::de::Error::duplicate_field("definition"));
4144                            }
4145                            definition__ = Some(map_.next_value()?);
4146                        }
4147                        GeneratedField::ConnectionId => {
4148                            if connection_id__.is_some() {
4149                                return Err(serde::de::Error::duplicate_field("connectionId"));
4150                            }
4151                            connection_id__ = 
4152                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4153                            ;
4154                        }
4155                        GeneratedField::InitializedAtEpoch => {
4156                            if initialized_at_epoch__.is_some() {
4157                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4158                            }
4159                            initialized_at_epoch__ = 
4160                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4161                            ;
4162                        }
4163                        GeneratedField::CreatedAtEpoch => {
4164                            if created_at_epoch__.is_some() {
4165                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4166                            }
4167                            created_at_epoch__ = 
4168                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4169                            ;
4170                        }
4171                        GeneratedField::InitializedAtClusterVersion => {
4172                            if initialized_at_cluster_version__.is_some() {
4173                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4174                            }
4175                            initialized_at_cluster_version__ = map_.next_value()?;
4176                        }
4177                        GeneratedField::CreatedAtClusterVersion => {
4178                            if created_at_cluster_version__.is_some() {
4179                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4180                            }
4181                            created_at_cluster_version__ = map_.next_value()?;
4182                        }
4183                        GeneratedField::SecretRefs => {
4184                            if secret_refs__.is_some() {
4185                                return Err(serde::de::Error::duplicate_field("secretRefs"));
4186                            }
4187                            secret_refs__ = Some(
4188                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4189                            );
4190                        }
4191                        GeneratedField::Version => {
4192                            if version__.is_some() {
4193                                return Err(serde::de::Error::duplicate_field("version"));
4194                            }
4195                            version__ = 
4196                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4197                            ;
4198                        }
4199                        GeneratedField::RateLimit => {
4200                            if rate_limit__.is_some() {
4201                                return Err(serde::de::Error::duplicate_field("rateLimit"));
4202                            }
4203                            rate_limit__ = 
4204                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4205                            ;
4206                        }
4207                        GeneratedField::AssociatedTableId => {
4208                            if optional_associated_table_id__.is_some() {
4209                                return Err(serde::de::Error::duplicate_field("associatedTableId"));
4210                            }
4211                            optional_associated_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| source::OptionalAssociatedTableId::AssociatedTableId(x.0));
4212                        }
4213                    }
4214                }
4215                Ok(Source {
4216                    id: id__.unwrap_or_default(),
4217                    schema_id: schema_id__.unwrap_or_default(),
4218                    database_id: database_id__.unwrap_or_default(),
4219                    name: name__.unwrap_or_default(),
4220                    row_id_index: row_id_index__,
4221                    columns: columns__.unwrap_or_default(),
4222                    pk_column_ids: pk_column_ids__.unwrap_or_default(),
4223                    with_properties: with_properties__.unwrap_or_default(),
4224                    owner: owner__.unwrap_or_default(),
4225                    info: info__,
4226                    watermark_descs: watermark_descs__.unwrap_or_default(),
4227                    definition: definition__.unwrap_or_default(),
4228                    connection_id: connection_id__,
4229                    initialized_at_epoch: initialized_at_epoch__,
4230                    created_at_epoch: created_at_epoch__,
4231                    initialized_at_cluster_version: initialized_at_cluster_version__,
4232                    created_at_cluster_version: created_at_cluster_version__,
4233                    secret_refs: secret_refs__.unwrap_or_default(),
4234                    version: version__.unwrap_or_default(),
4235                    rate_limit: rate_limit__,
4236                    optional_associated_table_id: optional_associated_table_id__,
4237                })
4238            }
4239        }
4240        deserializer.deserialize_struct("catalog.Source", FIELDS, GeneratedVisitor)
4241    }
4242}
4243impl serde::Serialize for StreamJobStatus {
4244    #[allow(deprecated)]
4245    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4246    where
4247        S: serde::Serializer,
4248    {
4249        let variant = match self {
4250            Self::Unspecified => "STREAM_JOB_STATUS_UNSPECIFIED",
4251            Self::Creating => "STREAM_JOB_STATUS_CREATING",
4252            Self::Created => "STREAM_JOB_STATUS_CREATED",
4253        };
4254        serializer.serialize_str(variant)
4255    }
4256}
4257impl<'de> serde::Deserialize<'de> for StreamJobStatus {
4258    #[allow(deprecated)]
4259    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4260    where
4261        D: serde::Deserializer<'de>,
4262    {
4263        const FIELDS: &[&str] = &[
4264            "STREAM_JOB_STATUS_UNSPECIFIED",
4265            "STREAM_JOB_STATUS_CREATING",
4266            "STREAM_JOB_STATUS_CREATED",
4267        ];
4268
4269        struct GeneratedVisitor;
4270
4271        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4272            type Value = StreamJobStatus;
4273
4274            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4275                write!(formatter, "expected one of: {:?}", &FIELDS)
4276            }
4277
4278            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4279            where
4280                E: serde::de::Error,
4281            {
4282                i32::try_from(v)
4283                    .ok()
4284                    .and_then(|x| x.try_into().ok())
4285                    .ok_or_else(|| {
4286                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4287                    })
4288            }
4289
4290            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4291            where
4292                E: serde::de::Error,
4293            {
4294                i32::try_from(v)
4295                    .ok()
4296                    .and_then(|x| x.try_into().ok())
4297                    .ok_or_else(|| {
4298                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4299                    })
4300            }
4301
4302            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4303            where
4304                E: serde::de::Error,
4305            {
4306                match value {
4307                    "STREAM_JOB_STATUS_UNSPECIFIED" => Ok(StreamJobStatus::Unspecified),
4308                    "STREAM_JOB_STATUS_CREATING" => Ok(StreamJobStatus::Creating),
4309                    "STREAM_JOB_STATUS_CREATED" => Ok(StreamJobStatus::Created),
4310                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4311                }
4312            }
4313        }
4314        deserializer.deserialize_any(GeneratedVisitor)
4315    }
4316}
4317impl serde::Serialize for StreamSourceInfo {
4318    #[allow(deprecated)]
4319    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4320    where
4321        S: serde::Serializer,
4322    {
4323        use serde::ser::SerializeStruct;
4324        let mut len = 0;
4325        if self.row_format != 0 {
4326            len += 1;
4327        }
4328        if !self.row_schema_location.is_empty() {
4329            len += 1;
4330        }
4331        if self.use_schema_registry {
4332            len += 1;
4333        }
4334        if !self.proto_message_name.is_empty() {
4335            len += 1;
4336        }
4337        if self.csv_delimiter != 0 {
4338            len += 1;
4339        }
4340        if self.csv_has_header {
4341            len += 1;
4342        }
4343        if self.format != 0 {
4344            len += 1;
4345        }
4346        if self.row_encode != 0 {
4347            len += 1;
4348        }
4349        if self.name_strategy != 0 {
4350            len += 1;
4351        }
4352        if self.key_message_name.is_some() {
4353            len += 1;
4354        }
4355        if self.external_table.is_some() {
4356            len += 1;
4357        }
4358        if self.cdc_source_job {
4359            len += 1;
4360        }
4361        if self.is_distributed {
4362            len += 1;
4363        }
4364        if !self.format_encode_options.is_empty() {
4365            len += 1;
4366        }
4367        if !self.format_encode_secret_refs.is_empty() {
4368            len += 1;
4369        }
4370        if self.connection_id.is_some() {
4371            len += 1;
4372        }
4373        let mut struct_ser = serializer.serialize_struct("catalog.StreamSourceInfo", len)?;
4374        if self.row_format != 0 {
4375            let v = super::plan_common::RowFormatType::try_from(self.row_format)
4376                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_format)))?;
4377            struct_ser.serialize_field("rowFormat", &v)?;
4378        }
4379        if !self.row_schema_location.is_empty() {
4380            struct_ser.serialize_field("rowSchemaLocation", &self.row_schema_location)?;
4381        }
4382        if self.use_schema_registry {
4383            struct_ser.serialize_field("useSchemaRegistry", &self.use_schema_registry)?;
4384        }
4385        if !self.proto_message_name.is_empty() {
4386            struct_ser.serialize_field("protoMessageName", &self.proto_message_name)?;
4387        }
4388        if self.csv_delimiter != 0 {
4389            struct_ser.serialize_field("csvDelimiter", &self.csv_delimiter)?;
4390        }
4391        if self.csv_has_header {
4392            struct_ser.serialize_field("csvHasHeader", &self.csv_has_header)?;
4393        }
4394        if self.format != 0 {
4395            let v = super::plan_common::FormatType::try_from(self.format)
4396                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
4397            struct_ser.serialize_field("format", &v)?;
4398        }
4399        if self.row_encode != 0 {
4400            let v = super::plan_common::EncodeType::try_from(self.row_encode)
4401                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_encode)))?;
4402            struct_ser.serialize_field("rowEncode", &v)?;
4403        }
4404        if self.name_strategy != 0 {
4405            let v = SchemaRegistryNameStrategy::try_from(self.name_strategy)
4406                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.name_strategy)))?;
4407            struct_ser.serialize_field("nameStrategy", &v)?;
4408        }
4409        if let Some(v) = self.key_message_name.as_ref() {
4410            struct_ser.serialize_field("keyMessageName", v)?;
4411        }
4412        if let Some(v) = self.external_table.as_ref() {
4413            struct_ser.serialize_field("externalTable", v)?;
4414        }
4415        if self.cdc_source_job {
4416            struct_ser.serialize_field("cdcSourceJob", &self.cdc_source_job)?;
4417        }
4418        if self.is_distributed {
4419            struct_ser.serialize_field("isDistributed", &self.is_distributed)?;
4420        }
4421        if !self.format_encode_options.is_empty() {
4422            struct_ser.serialize_field("formatEncodeOptions", &self.format_encode_options)?;
4423        }
4424        if !self.format_encode_secret_refs.is_empty() {
4425            struct_ser.serialize_field("formatEncodeSecretRefs", &self.format_encode_secret_refs)?;
4426        }
4427        if let Some(v) = self.connection_id.as_ref() {
4428            struct_ser.serialize_field("connectionId", v)?;
4429        }
4430        struct_ser.end()
4431    }
4432}
4433impl<'de> serde::Deserialize<'de> for StreamSourceInfo {
4434    #[allow(deprecated)]
4435    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4436    where
4437        D: serde::Deserializer<'de>,
4438    {
4439        const FIELDS: &[&str] = &[
4440            "row_format",
4441            "rowFormat",
4442            "row_schema_location",
4443            "rowSchemaLocation",
4444            "use_schema_registry",
4445            "useSchemaRegistry",
4446            "proto_message_name",
4447            "protoMessageName",
4448            "csv_delimiter",
4449            "csvDelimiter",
4450            "csv_has_header",
4451            "csvHasHeader",
4452            "format",
4453            "row_encode",
4454            "rowEncode",
4455            "name_strategy",
4456            "nameStrategy",
4457            "key_message_name",
4458            "keyMessageName",
4459            "external_table",
4460            "externalTable",
4461            "cdc_source_job",
4462            "cdcSourceJob",
4463            "is_distributed",
4464            "isDistributed",
4465            "format_encode_options",
4466            "formatEncodeOptions",
4467            "format_encode_secret_refs",
4468            "formatEncodeSecretRefs",
4469            "connection_id",
4470            "connectionId",
4471        ];
4472
4473        #[allow(clippy::enum_variant_names)]
4474        enum GeneratedField {
4475            RowFormat,
4476            RowSchemaLocation,
4477            UseSchemaRegistry,
4478            ProtoMessageName,
4479            CsvDelimiter,
4480            CsvHasHeader,
4481            Format,
4482            RowEncode,
4483            NameStrategy,
4484            KeyMessageName,
4485            ExternalTable,
4486            CdcSourceJob,
4487            IsDistributed,
4488            FormatEncodeOptions,
4489            FormatEncodeSecretRefs,
4490            ConnectionId,
4491        }
4492        impl<'de> serde::Deserialize<'de> for GeneratedField {
4493            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4494            where
4495                D: serde::Deserializer<'de>,
4496            {
4497                struct GeneratedVisitor;
4498
4499                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4500                    type Value = GeneratedField;
4501
4502                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4503                        write!(formatter, "expected one of: {:?}", &FIELDS)
4504                    }
4505
4506                    #[allow(unused_variables)]
4507                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4508                    where
4509                        E: serde::de::Error,
4510                    {
4511                        match value {
4512                            "rowFormat" | "row_format" => Ok(GeneratedField::RowFormat),
4513                            "rowSchemaLocation" | "row_schema_location" => Ok(GeneratedField::RowSchemaLocation),
4514                            "useSchemaRegistry" | "use_schema_registry" => Ok(GeneratedField::UseSchemaRegistry),
4515                            "protoMessageName" | "proto_message_name" => Ok(GeneratedField::ProtoMessageName),
4516                            "csvDelimiter" | "csv_delimiter" => Ok(GeneratedField::CsvDelimiter),
4517                            "csvHasHeader" | "csv_has_header" => Ok(GeneratedField::CsvHasHeader),
4518                            "format" => Ok(GeneratedField::Format),
4519                            "rowEncode" | "row_encode" => Ok(GeneratedField::RowEncode),
4520                            "nameStrategy" | "name_strategy" => Ok(GeneratedField::NameStrategy),
4521                            "keyMessageName" | "key_message_name" => Ok(GeneratedField::KeyMessageName),
4522                            "externalTable" | "external_table" => Ok(GeneratedField::ExternalTable),
4523                            "cdcSourceJob" | "cdc_source_job" => Ok(GeneratedField::CdcSourceJob),
4524                            "isDistributed" | "is_distributed" => Ok(GeneratedField::IsDistributed),
4525                            "formatEncodeOptions" | "format_encode_options" => Ok(GeneratedField::FormatEncodeOptions),
4526                            "formatEncodeSecretRefs" | "format_encode_secret_refs" => Ok(GeneratedField::FormatEncodeSecretRefs),
4527                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4528                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4529                        }
4530                    }
4531                }
4532                deserializer.deserialize_identifier(GeneratedVisitor)
4533            }
4534        }
4535        struct GeneratedVisitor;
4536        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4537            type Value = StreamSourceInfo;
4538
4539            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4540                formatter.write_str("struct catalog.StreamSourceInfo")
4541            }
4542
4543            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSourceInfo, V::Error>
4544                where
4545                    V: serde::de::MapAccess<'de>,
4546            {
4547                let mut row_format__ = None;
4548                let mut row_schema_location__ = None;
4549                let mut use_schema_registry__ = None;
4550                let mut proto_message_name__ = None;
4551                let mut csv_delimiter__ = None;
4552                let mut csv_has_header__ = None;
4553                let mut format__ = None;
4554                let mut row_encode__ = None;
4555                let mut name_strategy__ = None;
4556                let mut key_message_name__ = None;
4557                let mut external_table__ = None;
4558                let mut cdc_source_job__ = None;
4559                let mut is_distributed__ = None;
4560                let mut format_encode_options__ = None;
4561                let mut format_encode_secret_refs__ = None;
4562                let mut connection_id__ = None;
4563                while let Some(k) = map_.next_key()? {
4564                    match k {
4565                        GeneratedField::RowFormat => {
4566                            if row_format__.is_some() {
4567                                return Err(serde::de::Error::duplicate_field("rowFormat"));
4568                            }
4569                            row_format__ = Some(map_.next_value::<super::plan_common::RowFormatType>()? as i32);
4570                        }
4571                        GeneratedField::RowSchemaLocation => {
4572                            if row_schema_location__.is_some() {
4573                                return Err(serde::de::Error::duplicate_field("rowSchemaLocation"));
4574                            }
4575                            row_schema_location__ = Some(map_.next_value()?);
4576                        }
4577                        GeneratedField::UseSchemaRegistry => {
4578                            if use_schema_registry__.is_some() {
4579                                return Err(serde::de::Error::duplicate_field("useSchemaRegistry"));
4580                            }
4581                            use_schema_registry__ = Some(map_.next_value()?);
4582                        }
4583                        GeneratedField::ProtoMessageName => {
4584                            if proto_message_name__.is_some() {
4585                                return Err(serde::de::Error::duplicate_field("protoMessageName"));
4586                            }
4587                            proto_message_name__ = Some(map_.next_value()?);
4588                        }
4589                        GeneratedField::CsvDelimiter => {
4590                            if csv_delimiter__.is_some() {
4591                                return Err(serde::de::Error::duplicate_field("csvDelimiter"));
4592                            }
4593                            csv_delimiter__ = 
4594                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4595                            ;
4596                        }
4597                        GeneratedField::CsvHasHeader => {
4598                            if csv_has_header__.is_some() {
4599                                return Err(serde::de::Error::duplicate_field("csvHasHeader"));
4600                            }
4601                            csv_has_header__ = Some(map_.next_value()?);
4602                        }
4603                        GeneratedField::Format => {
4604                            if format__.is_some() {
4605                                return Err(serde::de::Error::duplicate_field("format"));
4606                            }
4607                            format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
4608                        }
4609                        GeneratedField::RowEncode => {
4610                            if row_encode__.is_some() {
4611                                return Err(serde::de::Error::duplicate_field("rowEncode"));
4612                            }
4613                            row_encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
4614                        }
4615                        GeneratedField::NameStrategy => {
4616                            if name_strategy__.is_some() {
4617                                return Err(serde::de::Error::duplicate_field("nameStrategy"));
4618                            }
4619                            name_strategy__ = Some(map_.next_value::<SchemaRegistryNameStrategy>()? as i32);
4620                        }
4621                        GeneratedField::KeyMessageName => {
4622                            if key_message_name__.is_some() {
4623                                return Err(serde::de::Error::duplicate_field("keyMessageName"));
4624                            }
4625                            key_message_name__ = map_.next_value()?;
4626                        }
4627                        GeneratedField::ExternalTable => {
4628                            if external_table__.is_some() {
4629                                return Err(serde::de::Error::duplicate_field("externalTable"));
4630                            }
4631                            external_table__ = map_.next_value()?;
4632                        }
4633                        GeneratedField::CdcSourceJob => {
4634                            if cdc_source_job__.is_some() {
4635                                return Err(serde::de::Error::duplicate_field("cdcSourceJob"));
4636                            }
4637                            cdc_source_job__ = Some(map_.next_value()?);
4638                        }
4639                        GeneratedField::IsDistributed => {
4640                            if is_distributed__.is_some() {
4641                                return Err(serde::de::Error::duplicate_field("isDistributed"));
4642                            }
4643                            is_distributed__ = Some(map_.next_value()?);
4644                        }
4645                        GeneratedField::FormatEncodeOptions => {
4646                            if format_encode_options__.is_some() {
4647                                return Err(serde::de::Error::duplicate_field("formatEncodeOptions"));
4648                            }
4649                            format_encode_options__ = Some(
4650                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4651                            );
4652                        }
4653                        GeneratedField::FormatEncodeSecretRefs => {
4654                            if format_encode_secret_refs__.is_some() {
4655                                return Err(serde::de::Error::duplicate_field("formatEncodeSecretRefs"));
4656                            }
4657                            format_encode_secret_refs__ = Some(
4658                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4659                            );
4660                        }
4661                        GeneratedField::ConnectionId => {
4662                            if connection_id__.is_some() {
4663                                return Err(serde::de::Error::duplicate_field("connectionId"));
4664                            }
4665                            connection_id__ = 
4666                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4667                            ;
4668                        }
4669                    }
4670                }
4671                Ok(StreamSourceInfo {
4672                    row_format: row_format__.unwrap_or_default(),
4673                    row_schema_location: row_schema_location__.unwrap_or_default(),
4674                    use_schema_registry: use_schema_registry__.unwrap_or_default(),
4675                    proto_message_name: proto_message_name__.unwrap_or_default(),
4676                    csv_delimiter: csv_delimiter__.unwrap_or_default(),
4677                    csv_has_header: csv_has_header__.unwrap_or_default(),
4678                    format: format__.unwrap_or_default(),
4679                    row_encode: row_encode__.unwrap_or_default(),
4680                    name_strategy: name_strategy__.unwrap_or_default(),
4681                    key_message_name: key_message_name__,
4682                    external_table: external_table__,
4683                    cdc_source_job: cdc_source_job__.unwrap_or_default(),
4684                    is_distributed: is_distributed__.unwrap_or_default(),
4685                    format_encode_options: format_encode_options__.unwrap_or_default(),
4686                    format_encode_secret_refs: format_encode_secret_refs__.unwrap_or_default(),
4687                    connection_id: connection_id__,
4688                })
4689            }
4690        }
4691        deserializer.deserialize_struct("catalog.StreamSourceInfo", FIELDS, GeneratedVisitor)
4692    }
4693}
4694impl serde::Serialize for Subscription {
4695    #[allow(deprecated)]
4696    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4697    where
4698        S: serde::Serializer,
4699    {
4700        use serde::ser::SerializeStruct;
4701        let mut len = 0;
4702        if self.id != 0 {
4703            len += 1;
4704        }
4705        if !self.name.is_empty() {
4706            len += 1;
4707        }
4708        if !self.definition.is_empty() {
4709            len += 1;
4710        }
4711        if self.retention_seconds != 0 {
4712            len += 1;
4713        }
4714        if self.database_id != 0 {
4715            len += 1;
4716        }
4717        if self.schema_id != 0 {
4718            len += 1;
4719        }
4720        if self.dependent_table_id != 0 {
4721            len += 1;
4722        }
4723        if self.initialized_at_epoch.is_some() {
4724            len += 1;
4725        }
4726        if self.created_at_epoch.is_some() {
4727            len += 1;
4728        }
4729        if self.owner != 0 {
4730            len += 1;
4731        }
4732        if self.initialized_at_cluster_version.is_some() {
4733            len += 1;
4734        }
4735        if self.created_at_cluster_version.is_some() {
4736            len += 1;
4737        }
4738        if self.subscription_state != 0 {
4739            len += 1;
4740        }
4741        let mut struct_ser = serializer.serialize_struct("catalog.Subscription", len)?;
4742        if self.id != 0 {
4743            struct_ser.serialize_field("id", &self.id)?;
4744        }
4745        if !self.name.is_empty() {
4746            struct_ser.serialize_field("name", &self.name)?;
4747        }
4748        if !self.definition.is_empty() {
4749            struct_ser.serialize_field("definition", &self.definition)?;
4750        }
4751        if self.retention_seconds != 0 {
4752            #[allow(clippy::needless_borrow)]
4753            #[allow(clippy::needless_borrows_for_generic_args)]
4754            struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
4755        }
4756        if self.database_id != 0 {
4757            struct_ser.serialize_field("databaseId", &self.database_id)?;
4758        }
4759        if self.schema_id != 0 {
4760            struct_ser.serialize_field("schemaId", &self.schema_id)?;
4761        }
4762        if self.dependent_table_id != 0 {
4763            struct_ser.serialize_field("dependentTableId", &self.dependent_table_id)?;
4764        }
4765        if let Some(v) = self.initialized_at_epoch.as_ref() {
4766            #[allow(clippy::needless_borrow)]
4767            #[allow(clippy::needless_borrows_for_generic_args)]
4768            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
4769        }
4770        if let Some(v) = self.created_at_epoch.as_ref() {
4771            #[allow(clippy::needless_borrow)]
4772            #[allow(clippy::needless_borrows_for_generic_args)]
4773            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
4774        }
4775        if self.owner != 0 {
4776            struct_ser.serialize_field("owner", &self.owner)?;
4777        }
4778        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
4779            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
4780        }
4781        if let Some(v) = self.created_at_cluster_version.as_ref() {
4782            struct_ser.serialize_field("createdAtClusterVersion", v)?;
4783        }
4784        if self.subscription_state != 0 {
4785            let v = subscription::SubscriptionState::try_from(self.subscription_state)
4786                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscription_state)))?;
4787            struct_ser.serialize_field("subscriptionState", &v)?;
4788        }
4789        struct_ser.end()
4790    }
4791}
4792impl<'de> serde::Deserialize<'de> for Subscription {
4793    #[allow(deprecated)]
4794    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4795    where
4796        D: serde::Deserializer<'de>,
4797    {
4798        const FIELDS: &[&str] = &[
4799            "id",
4800            "name",
4801            "definition",
4802            "retention_seconds",
4803            "retentionSeconds",
4804            "database_id",
4805            "databaseId",
4806            "schema_id",
4807            "schemaId",
4808            "dependent_table_id",
4809            "dependentTableId",
4810            "initialized_at_epoch",
4811            "initializedAtEpoch",
4812            "created_at_epoch",
4813            "createdAtEpoch",
4814            "owner",
4815            "initialized_at_cluster_version",
4816            "initializedAtClusterVersion",
4817            "created_at_cluster_version",
4818            "createdAtClusterVersion",
4819            "subscription_state",
4820            "subscriptionState",
4821        ];
4822
4823        #[allow(clippy::enum_variant_names)]
4824        enum GeneratedField {
4825            Id,
4826            Name,
4827            Definition,
4828            RetentionSeconds,
4829            DatabaseId,
4830            SchemaId,
4831            DependentTableId,
4832            InitializedAtEpoch,
4833            CreatedAtEpoch,
4834            Owner,
4835            InitializedAtClusterVersion,
4836            CreatedAtClusterVersion,
4837            SubscriptionState,
4838        }
4839        impl<'de> serde::Deserialize<'de> for GeneratedField {
4840            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4841            where
4842                D: serde::Deserializer<'de>,
4843            {
4844                struct GeneratedVisitor;
4845
4846                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4847                    type Value = GeneratedField;
4848
4849                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4850                        write!(formatter, "expected one of: {:?}", &FIELDS)
4851                    }
4852
4853                    #[allow(unused_variables)]
4854                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4855                    where
4856                        E: serde::de::Error,
4857                    {
4858                        match value {
4859                            "id" => Ok(GeneratedField::Id),
4860                            "name" => Ok(GeneratedField::Name),
4861                            "definition" => Ok(GeneratedField::Definition),
4862                            "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
4863                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4864                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4865                            "dependentTableId" | "dependent_table_id" => Ok(GeneratedField::DependentTableId),
4866                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4867                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4868                            "owner" => Ok(GeneratedField::Owner),
4869                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4870                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4871                            "subscriptionState" | "subscription_state" => Ok(GeneratedField::SubscriptionState),
4872                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4873                        }
4874                    }
4875                }
4876                deserializer.deserialize_identifier(GeneratedVisitor)
4877            }
4878        }
4879        struct GeneratedVisitor;
4880        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4881            type Value = Subscription;
4882
4883            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4884                formatter.write_str("struct catalog.Subscription")
4885            }
4886
4887            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Subscription, V::Error>
4888                where
4889                    V: serde::de::MapAccess<'de>,
4890            {
4891                let mut id__ = None;
4892                let mut name__ = None;
4893                let mut definition__ = None;
4894                let mut retention_seconds__ = None;
4895                let mut database_id__ = None;
4896                let mut schema_id__ = None;
4897                let mut dependent_table_id__ = None;
4898                let mut initialized_at_epoch__ = None;
4899                let mut created_at_epoch__ = None;
4900                let mut owner__ = None;
4901                let mut initialized_at_cluster_version__ = None;
4902                let mut created_at_cluster_version__ = None;
4903                let mut subscription_state__ = None;
4904                while let Some(k) = map_.next_key()? {
4905                    match k {
4906                        GeneratedField::Id => {
4907                            if id__.is_some() {
4908                                return Err(serde::de::Error::duplicate_field("id"));
4909                            }
4910                            id__ = 
4911                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4912                            ;
4913                        }
4914                        GeneratedField::Name => {
4915                            if name__.is_some() {
4916                                return Err(serde::de::Error::duplicate_field("name"));
4917                            }
4918                            name__ = Some(map_.next_value()?);
4919                        }
4920                        GeneratedField::Definition => {
4921                            if definition__.is_some() {
4922                                return Err(serde::de::Error::duplicate_field("definition"));
4923                            }
4924                            definition__ = Some(map_.next_value()?);
4925                        }
4926                        GeneratedField::RetentionSeconds => {
4927                            if retention_seconds__.is_some() {
4928                                return Err(serde::de::Error::duplicate_field("retentionSeconds"));
4929                            }
4930                            retention_seconds__ = 
4931                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4932                            ;
4933                        }
4934                        GeneratedField::DatabaseId => {
4935                            if database_id__.is_some() {
4936                                return Err(serde::de::Error::duplicate_field("databaseId"));
4937                            }
4938                            database_id__ = 
4939                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4940                            ;
4941                        }
4942                        GeneratedField::SchemaId => {
4943                            if schema_id__.is_some() {
4944                                return Err(serde::de::Error::duplicate_field("schemaId"));
4945                            }
4946                            schema_id__ = 
4947                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4948                            ;
4949                        }
4950                        GeneratedField::DependentTableId => {
4951                            if dependent_table_id__.is_some() {
4952                                return Err(serde::de::Error::duplicate_field("dependentTableId"));
4953                            }
4954                            dependent_table_id__ = 
4955                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4956                            ;
4957                        }
4958                        GeneratedField::InitializedAtEpoch => {
4959                            if initialized_at_epoch__.is_some() {
4960                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4961                            }
4962                            initialized_at_epoch__ = 
4963                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4964                            ;
4965                        }
4966                        GeneratedField::CreatedAtEpoch => {
4967                            if created_at_epoch__.is_some() {
4968                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4969                            }
4970                            created_at_epoch__ = 
4971                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4972                            ;
4973                        }
4974                        GeneratedField::Owner => {
4975                            if owner__.is_some() {
4976                                return Err(serde::de::Error::duplicate_field("owner"));
4977                            }
4978                            owner__ = 
4979                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4980                            ;
4981                        }
4982                        GeneratedField::InitializedAtClusterVersion => {
4983                            if initialized_at_cluster_version__.is_some() {
4984                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4985                            }
4986                            initialized_at_cluster_version__ = map_.next_value()?;
4987                        }
4988                        GeneratedField::CreatedAtClusterVersion => {
4989                            if created_at_cluster_version__.is_some() {
4990                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4991                            }
4992                            created_at_cluster_version__ = map_.next_value()?;
4993                        }
4994                        GeneratedField::SubscriptionState => {
4995                            if subscription_state__.is_some() {
4996                                return Err(serde::de::Error::duplicate_field("subscriptionState"));
4997                            }
4998                            subscription_state__ = Some(map_.next_value::<subscription::SubscriptionState>()? as i32);
4999                        }
5000                    }
5001                }
5002                Ok(Subscription {
5003                    id: id__.unwrap_or_default(),
5004                    name: name__.unwrap_or_default(),
5005                    definition: definition__.unwrap_or_default(),
5006                    retention_seconds: retention_seconds__.unwrap_or_default(),
5007                    database_id: database_id__.unwrap_or_default(),
5008                    schema_id: schema_id__.unwrap_or_default(),
5009                    dependent_table_id: dependent_table_id__.unwrap_or_default(),
5010                    initialized_at_epoch: initialized_at_epoch__,
5011                    created_at_epoch: created_at_epoch__,
5012                    owner: owner__.unwrap_or_default(),
5013                    initialized_at_cluster_version: initialized_at_cluster_version__,
5014                    created_at_cluster_version: created_at_cluster_version__,
5015                    subscription_state: subscription_state__.unwrap_or_default(),
5016                })
5017            }
5018        }
5019        deserializer.deserialize_struct("catalog.Subscription", FIELDS, GeneratedVisitor)
5020    }
5021}
5022impl serde::Serialize for subscription::SubscriptionState {
5023    #[allow(deprecated)]
5024    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5025    where
5026        S: serde::Serializer,
5027    {
5028        let variant = match self {
5029            Self::Unspecified => "UNSPECIFIED",
5030            Self::Init => "INIT",
5031            Self::Created => "CREATED",
5032        };
5033        serializer.serialize_str(variant)
5034    }
5035}
5036impl<'de> serde::Deserialize<'de> for subscription::SubscriptionState {
5037    #[allow(deprecated)]
5038    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5039    where
5040        D: serde::Deserializer<'de>,
5041    {
5042        const FIELDS: &[&str] = &[
5043            "UNSPECIFIED",
5044            "INIT",
5045            "CREATED",
5046        ];
5047
5048        struct GeneratedVisitor;
5049
5050        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5051            type Value = subscription::SubscriptionState;
5052
5053            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5054                write!(formatter, "expected one of: {:?}", &FIELDS)
5055            }
5056
5057            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5058            where
5059                E: serde::de::Error,
5060            {
5061                i32::try_from(v)
5062                    .ok()
5063                    .and_then(|x| x.try_into().ok())
5064                    .ok_or_else(|| {
5065                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5066                    })
5067            }
5068
5069            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5070            where
5071                E: serde::de::Error,
5072            {
5073                i32::try_from(v)
5074                    .ok()
5075                    .and_then(|x| x.try_into().ok())
5076                    .ok_or_else(|| {
5077                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5078                    })
5079            }
5080
5081            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5082            where
5083                E: serde::de::Error,
5084            {
5085                match value {
5086                    "UNSPECIFIED" => Ok(subscription::SubscriptionState::Unspecified),
5087                    "INIT" => Ok(subscription::SubscriptionState::Init),
5088                    "CREATED" => Ok(subscription::SubscriptionState::Created),
5089                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5090                }
5091            }
5092        }
5093        deserializer.deserialize_any(GeneratedVisitor)
5094    }
5095}
5096impl serde::Serialize for Table {
5097    #[allow(deprecated)]
5098    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5099    where
5100        S: serde::Serializer,
5101    {
5102        use serde::ser::SerializeStruct;
5103        let mut len = 0;
5104        if self.id != 0 {
5105            len += 1;
5106        }
5107        if self.schema_id != 0 {
5108            len += 1;
5109        }
5110        if self.database_id != 0 {
5111            len += 1;
5112        }
5113        if !self.name.is_empty() {
5114            len += 1;
5115        }
5116        if !self.columns.is_empty() {
5117            len += 1;
5118        }
5119        if !self.pk.is_empty() {
5120            len += 1;
5121        }
5122        if self.table_type != 0 {
5123            len += 1;
5124        }
5125        if !self.distribution_key.is_empty() {
5126            len += 1;
5127        }
5128        if !self.stream_key.is_empty() {
5129            len += 1;
5130        }
5131        if self.append_only {
5132            len += 1;
5133        }
5134        if self.owner != 0 {
5135            len += 1;
5136        }
5137        if self.fragment_id != 0 {
5138            len += 1;
5139        }
5140        if self.vnode_col_index.is_some() {
5141            len += 1;
5142        }
5143        if self.row_id_index.is_some() {
5144            len += 1;
5145        }
5146        if !self.value_indices.is_empty() {
5147            len += 1;
5148        }
5149        if !self.definition.is_empty() {
5150            len += 1;
5151        }
5152        if self.handle_pk_conflict_behavior != 0 {
5153            len += 1;
5154        }
5155        if self.read_prefix_len_hint != 0 {
5156            len += 1;
5157        }
5158        if !self.watermark_indices.is_empty() {
5159            len += 1;
5160        }
5161        if !self.dist_key_in_pk.is_empty() {
5162            len += 1;
5163        }
5164        if self.dml_fragment_id.is_some() {
5165            len += 1;
5166        }
5167        if self.cardinality.is_some() {
5168            len += 1;
5169        }
5170        if self.initialized_at_epoch.is_some() {
5171            len += 1;
5172        }
5173        if self.created_at_epoch.is_some() {
5174            len += 1;
5175        }
5176        if self.cleaned_by_watermark {
5177            len += 1;
5178        }
5179        if self.stream_job_status != 0 {
5180            len += 1;
5181        }
5182        if self.create_type != 0 {
5183            len += 1;
5184        }
5185        if self.description.is_some() {
5186            len += 1;
5187        }
5188        if !self.incoming_sinks.is_empty() {
5189            len += 1;
5190        }
5191        if self.initialized_at_cluster_version.is_some() {
5192            len += 1;
5193        }
5194        if self.created_at_cluster_version.is_some() {
5195            len += 1;
5196        }
5197        if self.retention_seconds.is_some() {
5198            len += 1;
5199        }
5200        if self.version_column_index.is_some() {
5201            len += 1;
5202        }
5203        if self.cdc_table_id.is_some() {
5204            len += 1;
5205        }
5206        if self.maybe_vnode_count.is_some() {
5207            len += 1;
5208        }
5209        if self.webhook_info.is_some() {
5210            len += 1;
5211        }
5212        if self.job_id.is_some() {
5213            len += 1;
5214        }
5215        if self.engine.is_some() {
5216            len += 1;
5217        }
5218        if self.clean_watermark_index_in_pk.is_some() {
5219            len += 1;
5220        }
5221        if self.version.is_some() {
5222            len += 1;
5223        }
5224        if self.optional_associated_source_id.is_some() {
5225            len += 1;
5226        }
5227        let mut struct_ser = serializer.serialize_struct("catalog.Table", len)?;
5228        if self.id != 0 {
5229            struct_ser.serialize_field("id", &self.id)?;
5230        }
5231        if self.schema_id != 0 {
5232            struct_ser.serialize_field("schemaId", &self.schema_id)?;
5233        }
5234        if self.database_id != 0 {
5235            struct_ser.serialize_field("databaseId", &self.database_id)?;
5236        }
5237        if !self.name.is_empty() {
5238            struct_ser.serialize_field("name", &self.name)?;
5239        }
5240        if !self.columns.is_empty() {
5241            struct_ser.serialize_field("columns", &self.columns)?;
5242        }
5243        if !self.pk.is_empty() {
5244            struct_ser.serialize_field("pk", &self.pk)?;
5245        }
5246        if self.table_type != 0 {
5247            let v = table::TableType::try_from(self.table_type)
5248                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
5249            struct_ser.serialize_field("tableType", &v)?;
5250        }
5251        if !self.distribution_key.is_empty() {
5252            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
5253        }
5254        if !self.stream_key.is_empty() {
5255            struct_ser.serialize_field("streamKey", &self.stream_key)?;
5256        }
5257        if self.append_only {
5258            struct_ser.serialize_field("appendOnly", &self.append_only)?;
5259        }
5260        if self.owner != 0 {
5261            struct_ser.serialize_field("owner", &self.owner)?;
5262        }
5263        if self.fragment_id != 0 {
5264            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5265        }
5266        if let Some(v) = self.vnode_col_index.as_ref() {
5267            struct_ser.serialize_field("vnodeColIndex", v)?;
5268        }
5269        if let Some(v) = self.row_id_index.as_ref() {
5270            struct_ser.serialize_field("rowIdIndex", v)?;
5271        }
5272        if !self.value_indices.is_empty() {
5273            struct_ser.serialize_field("valueIndices", &self.value_indices)?;
5274        }
5275        if !self.definition.is_empty() {
5276            struct_ser.serialize_field("definition", &self.definition)?;
5277        }
5278        if self.handle_pk_conflict_behavior != 0 {
5279            let v = HandleConflictBehavior::try_from(self.handle_pk_conflict_behavior)
5280                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.handle_pk_conflict_behavior)))?;
5281            struct_ser.serialize_field("handlePkConflictBehavior", &v)?;
5282        }
5283        if self.read_prefix_len_hint != 0 {
5284            struct_ser.serialize_field("readPrefixLenHint", &self.read_prefix_len_hint)?;
5285        }
5286        if !self.watermark_indices.is_empty() {
5287            struct_ser.serialize_field("watermarkIndices", &self.watermark_indices)?;
5288        }
5289        if !self.dist_key_in_pk.is_empty() {
5290            struct_ser.serialize_field("distKeyInPk", &self.dist_key_in_pk)?;
5291        }
5292        if let Some(v) = self.dml_fragment_id.as_ref() {
5293            struct_ser.serialize_field("dmlFragmentId", v)?;
5294        }
5295        if let Some(v) = self.cardinality.as_ref() {
5296            struct_ser.serialize_field("cardinality", v)?;
5297        }
5298        if let Some(v) = self.initialized_at_epoch.as_ref() {
5299            #[allow(clippy::needless_borrow)]
5300            #[allow(clippy::needless_borrows_for_generic_args)]
5301            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5302        }
5303        if let Some(v) = self.created_at_epoch.as_ref() {
5304            #[allow(clippy::needless_borrow)]
5305            #[allow(clippy::needless_borrows_for_generic_args)]
5306            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5307        }
5308        if self.cleaned_by_watermark {
5309            struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
5310        }
5311        if self.stream_job_status != 0 {
5312            let v = StreamJobStatus::try_from(self.stream_job_status)
5313                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
5314            struct_ser.serialize_field("streamJobStatus", &v)?;
5315        }
5316        if self.create_type != 0 {
5317            let v = CreateType::try_from(self.create_type)
5318                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
5319            struct_ser.serialize_field("createType", &v)?;
5320        }
5321        if let Some(v) = self.description.as_ref() {
5322            struct_ser.serialize_field("description", v)?;
5323        }
5324        if !self.incoming_sinks.is_empty() {
5325            struct_ser.serialize_field("incomingSinks", &self.incoming_sinks)?;
5326        }
5327        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5328            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5329        }
5330        if let Some(v) = self.created_at_cluster_version.as_ref() {
5331            struct_ser.serialize_field("createdAtClusterVersion", v)?;
5332        }
5333        if let Some(v) = self.retention_seconds.as_ref() {
5334            struct_ser.serialize_field("retentionSeconds", v)?;
5335        }
5336        if let Some(v) = self.version_column_index.as_ref() {
5337            struct_ser.serialize_field("versionColumnIndex", v)?;
5338        }
5339        if let Some(v) = self.cdc_table_id.as_ref() {
5340            struct_ser.serialize_field("cdcTableId", v)?;
5341        }
5342        if let Some(v) = self.maybe_vnode_count.as_ref() {
5343            struct_ser.serialize_field("maybeVnodeCount", v)?;
5344        }
5345        if let Some(v) = self.webhook_info.as_ref() {
5346            struct_ser.serialize_field("webhookInfo", v)?;
5347        }
5348        if let Some(v) = self.job_id.as_ref() {
5349            struct_ser.serialize_field("jobId", v)?;
5350        }
5351        if let Some(v) = self.engine.as_ref() {
5352            let v = table::Engine::try_from(*v)
5353                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5354            struct_ser.serialize_field("engine", &v)?;
5355        }
5356        if let Some(v) = self.clean_watermark_index_in_pk.as_ref() {
5357            struct_ser.serialize_field("cleanWatermarkIndexInPk", v)?;
5358        }
5359        if let Some(v) = self.version.as_ref() {
5360            struct_ser.serialize_field("version", v)?;
5361        }
5362        if let Some(v) = self.optional_associated_source_id.as_ref() {
5363            match v {
5364                table::OptionalAssociatedSourceId::AssociatedSourceId(v) => {
5365                    struct_ser.serialize_field("associatedSourceId", v)?;
5366                }
5367            }
5368        }
5369        struct_ser.end()
5370    }
5371}
5372impl<'de> serde::Deserialize<'de> for Table {
5373    #[allow(deprecated)]
5374    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5375    where
5376        D: serde::Deserializer<'de>,
5377    {
5378        const FIELDS: &[&str] = &[
5379            "id",
5380            "schema_id",
5381            "schemaId",
5382            "database_id",
5383            "databaseId",
5384            "name",
5385            "columns",
5386            "pk",
5387            "table_type",
5388            "tableType",
5389            "distribution_key",
5390            "distributionKey",
5391            "stream_key",
5392            "streamKey",
5393            "append_only",
5394            "appendOnly",
5395            "owner",
5396            "fragment_id",
5397            "fragmentId",
5398            "vnode_col_index",
5399            "vnodeColIndex",
5400            "row_id_index",
5401            "rowIdIndex",
5402            "value_indices",
5403            "valueIndices",
5404            "definition",
5405            "handle_pk_conflict_behavior",
5406            "handlePkConflictBehavior",
5407            "read_prefix_len_hint",
5408            "readPrefixLenHint",
5409            "watermark_indices",
5410            "watermarkIndices",
5411            "dist_key_in_pk",
5412            "distKeyInPk",
5413            "dml_fragment_id",
5414            "dmlFragmentId",
5415            "cardinality",
5416            "initialized_at_epoch",
5417            "initializedAtEpoch",
5418            "created_at_epoch",
5419            "createdAtEpoch",
5420            "cleaned_by_watermark",
5421            "cleanedByWatermark",
5422            "stream_job_status",
5423            "streamJobStatus",
5424            "create_type",
5425            "createType",
5426            "description",
5427            "incoming_sinks",
5428            "incomingSinks",
5429            "initialized_at_cluster_version",
5430            "initializedAtClusterVersion",
5431            "created_at_cluster_version",
5432            "createdAtClusterVersion",
5433            "retention_seconds",
5434            "retentionSeconds",
5435            "version_column_index",
5436            "versionColumnIndex",
5437            "cdc_table_id",
5438            "cdcTableId",
5439            "maybe_vnode_count",
5440            "maybeVnodeCount",
5441            "webhook_info",
5442            "webhookInfo",
5443            "job_id",
5444            "jobId",
5445            "engine",
5446            "clean_watermark_index_in_pk",
5447            "cleanWatermarkIndexInPk",
5448            "version",
5449            "associated_source_id",
5450            "associatedSourceId",
5451        ];
5452
5453        #[allow(clippy::enum_variant_names)]
5454        enum GeneratedField {
5455            Id,
5456            SchemaId,
5457            DatabaseId,
5458            Name,
5459            Columns,
5460            Pk,
5461            TableType,
5462            DistributionKey,
5463            StreamKey,
5464            AppendOnly,
5465            Owner,
5466            FragmentId,
5467            VnodeColIndex,
5468            RowIdIndex,
5469            ValueIndices,
5470            Definition,
5471            HandlePkConflictBehavior,
5472            ReadPrefixLenHint,
5473            WatermarkIndices,
5474            DistKeyInPk,
5475            DmlFragmentId,
5476            Cardinality,
5477            InitializedAtEpoch,
5478            CreatedAtEpoch,
5479            CleanedByWatermark,
5480            StreamJobStatus,
5481            CreateType,
5482            Description,
5483            IncomingSinks,
5484            InitializedAtClusterVersion,
5485            CreatedAtClusterVersion,
5486            RetentionSeconds,
5487            VersionColumnIndex,
5488            CdcTableId,
5489            MaybeVnodeCount,
5490            WebhookInfo,
5491            JobId,
5492            Engine,
5493            CleanWatermarkIndexInPk,
5494            Version,
5495            AssociatedSourceId,
5496        }
5497        impl<'de> serde::Deserialize<'de> for GeneratedField {
5498            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5499            where
5500                D: serde::Deserializer<'de>,
5501            {
5502                struct GeneratedVisitor;
5503
5504                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5505                    type Value = GeneratedField;
5506
5507                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5508                        write!(formatter, "expected one of: {:?}", &FIELDS)
5509                    }
5510
5511                    #[allow(unused_variables)]
5512                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5513                    where
5514                        E: serde::de::Error,
5515                    {
5516                        match value {
5517                            "id" => Ok(GeneratedField::Id),
5518                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5519                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5520                            "name" => Ok(GeneratedField::Name),
5521                            "columns" => Ok(GeneratedField::Columns),
5522                            "pk" => Ok(GeneratedField::Pk),
5523                            "tableType" | "table_type" => Ok(GeneratedField::TableType),
5524                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
5525                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5526                            "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
5527                            "owner" => Ok(GeneratedField::Owner),
5528                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5529                            "vnodeColIndex" | "vnode_col_index" => Ok(GeneratedField::VnodeColIndex),
5530                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
5531                            "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
5532                            "definition" => Ok(GeneratedField::Definition),
5533                            "handlePkConflictBehavior" | "handle_pk_conflict_behavior" => Ok(GeneratedField::HandlePkConflictBehavior),
5534                            "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
5535                            "watermarkIndices" | "watermark_indices" => Ok(GeneratedField::WatermarkIndices),
5536                            "distKeyInPk" | "dist_key_in_pk" => Ok(GeneratedField::DistKeyInPk),
5537                            "dmlFragmentId" | "dml_fragment_id" => Ok(GeneratedField::DmlFragmentId),
5538                            "cardinality" => Ok(GeneratedField::Cardinality),
5539                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5540                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5541                            "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
5542                            "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
5543                            "createType" | "create_type" => Ok(GeneratedField::CreateType),
5544                            "description" => Ok(GeneratedField::Description),
5545                            "incomingSinks" | "incoming_sinks" => Ok(GeneratedField::IncomingSinks),
5546                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5547                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5548                            "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5549                            "versionColumnIndex" | "version_column_index" => Ok(GeneratedField::VersionColumnIndex),
5550                            "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
5551                            "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
5552                            "webhookInfo" | "webhook_info" => Ok(GeneratedField::WebhookInfo),
5553                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
5554                            "engine" => Ok(GeneratedField::Engine),
5555                            "cleanWatermarkIndexInPk" | "clean_watermark_index_in_pk" => Ok(GeneratedField::CleanWatermarkIndexInPk),
5556                            "version" => Ok(GeneratedField::Version),
5557                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
5558                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5559                        }
5560                    }
5561                }
5562                deserializer.deserialize_identifier(GeneratedVisitor)
5563            }
5564        }
5565        struct GeneratedVisitor;
5566        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5567            type Value = Table;
5568
5569            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5570                formatter.write_str("struct catalog.Table")
5571            }
5572
5573            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
5574                where
5575                    V: serde::de::MapAccess<'de>,
5576            {
5577                let mut id__ = None;
5578                let mut schema_id__ = None;
5579                let mut database_id__ = None;
5580                let mut name__ = None;
5581                let mut columns__ = None;
5582                let mut pk__ = None;
5583                let mut table_type__ = None;
5584                let mut distribution_key__ = None;
5585                let mut stream_key__ = None;
5586                let mut append_only__ = None;
5587                let mut owner__ = None;
5588                let mut fragment_id__ = None;
5589                let mut vnode_col_index__ = None;
5590                let mut row_id_index__ = None;
5591                let mut value_indices__ = None;
5592                let mut definition__ = None;
5593                let mut handle_pk_conflict_behavior__ = None;
5594                let mut read_prefix_len_hint__ = None;
5595                let mut watermark_indices__ = None;
5596                let mut dist_key_in_pk__ = None;
5597                let mut dml_fragment_id__ = None;
5598                let mut cardinality__ = None;
5599                let mut initialized_at_epoch__ = None;
5600                let mut created_at_epoch__ = None;
5601                let mut cleaned_by_watermark__ = None;
5602                let mut stream_job_status__ = None;
5603                let mut create_type__ = None;
5604                let mut description__ = None;
5605                let mut incoming_sinks__ = None;
5606                let mut initialized_at_cluster_version__ = None;
5607                let mut created_at_cluster_version__ = None;
5608                let mut retention_seconds__ = None;
5609                let mut version_column_index__ = None;
5610                let mut cdc_table_id__ = None;
5611                let mut maybe_vnode_count__ = None;
5612                let mut webhook_info__ = None;
5613                let mut job_id__ = None;
5614                let mut engine__ = None;
5615                let mut clean_watermark_index_in_pk__ = None;
5616                let mut version__ = None;
5617                let mut optional_associated_source_id__ = None;
5618                while let Some(k) = map_.next_key()? {
5619                    match k {
5620                        GeneratedField::Id => {
5621                            if id__.is_some() {
5622                                return Err(serde::de::Error::duplicate_field("id"));
5623                            }
5624                            id__ = 
5625                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5626                            ;
5627                        }
5628                        GeneratedField::SchemaId => {
5629                            if schema_id__.is_some() {
5630                                return Err(serde::de::Error::duplicate_field("schemaId"));
5631                            }
5632                            schema_id__ = 
5633                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5634                            ;
5635                        }
5636                        GeneratedField::DatabaseId => {
5637                            if database_id__.is_some() {
5638                                return Err(serde::de::Error::duplicate_field("databaseId"));
5639                            }
5640                            database_id__ = 
5641                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5642                            ;
5643                        }
5644                        GeneratedField::Name => {
5645                            if name__.is_some() {
5646                                return Err(serde::de::Error::duplicate_field("name"));
5647                            }
5648                            name__ = Some(map_.next_value()?);
5649                        }
5650                        GeneratedField::Columns => {
5651                            if columns__.is_some() {
5652                                return Err(serde::de::Error::duplicate_field("columns"));
5653                            }
5654                            columns__ = Some(map_.next_value()?);
5655                        }
5656                        GeneratedField::Pk => {
5657                            if pk__.is_some() {
5658                                return Err(serde::de::Error::duplicate_field("pk"));
5659                            }
5660                            pk__ = Some(map_.next_value()?);
5661                        }
5662                        GeneratedField::TableType => {
5663                            if table_type__.is_some() {
5664                                return Err(serde::de::Error::duplicate_field("tableType"));
5665                            }
5666                            table_type__ = Some(map_.next_value::<table::TableType>()? as i32);
5667                        }
5668                        GeneratedField::DistributionKey => {
5669                            if distribution_key__.is_some() {
5670                                return Err(serde::de::Error::duplicate_field("distributionKey"));
5671                            }
5672                            distribution_key__ = 
5673                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5674                                    .into_iter().map(|x| x.0).collect())
5675                            ;
5676                        }
5677                        GeneratedField::StreamKey => {
5678                            if stream_key__.is_some() {
5679                                return Err(serde::de::Error::duplicate_field("streamKey"));
5680                            }
5681                            stream_key__ = 
5682                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5683                                    .into_iter().map(|x| x.0).collect())
5684                            ;
5685                        }
5686                        GeneratedField::AppendOnly => {
5687                            if append_only__.is_some() {
5688                                return Err(serde::de::Error::duplicate_field("appendOnly"));
5689                            }
5690                            append_only__ = Some(map_.next_value()?);
5691                        }
5692                        GeneratedField::Owner => {
5693                            if owner__.is_some() {
5694                                return Err(serde::de::Error::duplicate_field("owner"));
5695                            }
5696                            owner__ = 
5697                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5698                            ;
5699                        }
5700                        GeneratedField::FragmentId => {
5701                            if fragment_id__.is_some() {
5702                                return Err(serde::de::Error::duplicate_field("fragmentId"));
5703                            }
5704                            fragment_id__ = 
5705                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5706                            ;
5707                        }
5708                        GeneratedField::VnodeColIndex => {
5709                            if vnode_col_index__.is_some() {
5710                                return Err(serde::de::Error::duplicate_field("vnodeColIndex"));
5711                            }
5712                            vnode_col_index__ = 
5713                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5714                            ;
5715                        }
5716                        GeneratedField::RowIdIndex => {
5717                            if row_id_index__.is_some() {
5718                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
5719                            }
5720                            row_id_index__ = 
5721                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5722                            ;
5723                        }
5724                        GeneratedField::ValueIndices => {
5725                            if value_indices__.is_some() {
5726                                return Err(serde::de::Error::duplicate_field("valueIndices"));
5727                            }
5728                            value_indices__ = 
5729                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5730                                    .into_iter().map(|x| x.0).collect())
5731                            ;
5732                        }
5733                        GeneratedField::Definition => {
5734                            if definition__.is_some() {
5735                                return Err(serde::de::Error::duplicate_field("definition"));
5736                            }
5737                            definition__ = Some(map_.next_value()?);
5738                        }
5739                        GeneratedField::HandlePkConflictBehavior => {
5740                            if handle_pk_conflict_behavior__.is_some() {
5741                                return Err(serde::de::Error::duplicate_field("handlePkConflictBehavior"));
5742                            }
5743                            handle_pk_conflict_behavior__ = Some(map_.next_value::<HandleConflictBehavior>()? as i32);
5744                        }
5745                        GeneratedField::ReadPrefixLenHint => {
5746                            if read_prefix_len_hint__.is_some() {
5747                                return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
5748                            }
5749                            read_prefix_len_hint__ = 
5750                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5751                            ;
5752                        }
5753                        GeneratedField::WatermarkIndices => {
5754                            if watermark_indices__.is_some() {
5755                                return Err(serde::de::Error::duplicate_field("watermarkIndices"));
5756                            }
5757                            watermark_indices__ = 
5758                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5759                                    .into_iter().map(|x| x.0).collect())
5760                            ;
5761                        }
5762                        GeneratedField::DistKeyInPk => {
5763                            if dist_key_in_pk__.is_some() {
5764                                return Err(serde::de::Error::duplicate_field("distKeyInPk"));
5765                            }
5766                            dist_key_in_pk__ = 
5767                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5768                                    .into_iter().map(|x| x.0).collect())
5769                            ;
5770                        }
5771                        GeneratedField::DmlFragmentId => {
5772                            if dml_fragment_id__.is_some() {
5773                                return Err(serde::de::Error::duplicate_field("dmlFragmentId"));
5774                            }
5775                            dml_fragment_id__ = 
5776                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5777                            ;
5778                        }
5779                        GeneratedField::Cardinality => {
5780                            if cardinality__.is_some() {
5781                                return Err(serde::de::Error::duplicate_field("cardinality"));
5782                            }
5783                            cardinality__ = map_.next_value()?;
5784                        }
5785                        GeneratedField::InitializedAtEpoch => {
5786                            if initialized_at_epoch__.is_some() {
5787                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
5788                            }
5789                            initialized_at_epoch__ = 
5790                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5791                            ;
5792                        }
5793                        GeneratedField::CreatedAtEpoch => {
5794                            if created_at_epoch__.is_some() {
5795                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
5796                            }
5797                            created_at_epoch__ = 
5798                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5799                            ;
5800                        }
5801                        GeneratedField::CleanedByWatermark => {
5802                            if cleaned_by_watermark__.is_some() {
5803                                return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
5804                            }
5805                            cleaned_by_watermark__ = Some(map_.next_value()?);
5806                        }
5807                        GeneratedField::StreamJobStatus => {
5808                            if stream_job_status__.is_some() {
5809                                return Err(serde::de::Error::duplicate_field("streamJobStatus"));
5810                            }
5811                            stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
5812                        }
5813                        GeneratedField::CreateType => {
5814                            if create_type__.is_some() {
5815                                return Err(serde::de::Error::duplicate_field("createType"));
5816                            }
5817                            create_type__ = Some(map_.next_value::<CreateType>()? as i32);
5818                        }
5819                        GeneratedField::Description => {
5820                            if description__.is_some() {
5821                                return Err(serde::de::Error::duplicate_field("description"));
5822                            }
5823                            description__ = map_.next_value()?;
5824                        }
5825                        GeneratedField::IncomingSinks => {
5826                            if incoming_sinks__.is_some() {
5827                                return Err(serde::de::Error::duplicate_field("incomingSinks"));
5828                            }
5829                            incoming_sinks__ = 
5830                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5831                                    .into_iter().map(|x| x.0).collect())
5832                            ;
5833                        }
5834                        GeneratedField::InitializedAtClusterVersion => {
5835                            if initialized_at_cluster_version__.is_some() {
5836                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
5837                            }
5838                            initialized_at_cluster_version__ = map_.next_value()?;
5839                        }
5840                        GeneratedField::CreatedAtClusterVersion => {
5841                            if created_at_cluster_version__.is_some() {
5842                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
5843                            }
5844                            created_at_cluster_version__ = map_.next_value()?;
5845                        }
5846                        GeneratedField::RetentionSeconds => {
5847                            if retention_seconds__.is_some() {
5848                                return Err(serde::de::Error::duplicate_field("retentionSeconds"));
5849                            }
5850                            retention_seconds__ = 
5851                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5852                            ;
5853                        }
5854                        GeneratedField::VersionColumnIndex => {
5855                            if version_column_index__.is_some() {
5856                                return Err(serde::de::Error::duplicate_field("versionColumnIndex"));
5857                            }
5858                            version_column_index__ = 
5859                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5860                            ;
5861                        }
5862                        GeneratedField::CdcTableId => {
5863                            if cdc_table_id__.is_some() {
5864                                return Err(serde::de::Error::duplicate_field("cdcTableId"));
5865                            }
5866                            cdc_table_id__ = map_.next_value()?;
5867                        }
5868                        GeneratedField::MaybeVnodeCount => {
5869                            if maybe_vnode_count__.is_some() {
5870                                return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
5871                            }
5872                            maybe_vnode_count__ = 
5873                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5874                            ;
5875                        }
5876                        GeneratedField::WebhookInfo => {
5877                            if webhook_info__.is_some() {
5878                                return Err(serde::de::Error::duplicate_field("webhookInfo"));
5879                            }
5880                            webhook_info__ = map_.next_value()?;
5881                        }
5882                        GeneratedField::JobId => {
5883                            if job_id__.is_some() {
5884                                return Err(serde::de::Error::duplicate_field("jobId"));
5885                            }
5886                            job_id__ = 
5887                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5888                            ;
5889                        }
5890                        GeneratedField::Engine => {
5891                            if engine__.is_some() {
5892                                return Err(serde::de::Error::duplicate_field("engine"));
5893                            }
5894                            engine__ = map_.next_value::<::std::option::Option<table::Engine>>()?.map(|x| x as i32);
5895                        }
5896                        GeneratedField::CleanWatermarkIndexInPk => {
5897                            if clean_watermark_index_in_pk__.is_some() {
5898                                return Err(serde::de::Error::duplicate_field("cleanWatermarkIndexInPk"));
5899                            }
5900                            clean_watermark_index_in_pk__ = 
5901                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5902                            ;
5903                        }
5904                        GeneratedField::Version => {
5905                            if version__.is_some() {
5906                                return Err(serde::de::Error::duplicate_field("version"));
5907                            }
5908                            version__ = map_.next_value()?;
5909                        }
5910                        GeneratedField::AssociatedSourceId => {
5911                            if optional_associated_source_id__.is_some() {
5912                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
5913                            }
5914                            optional_associated_source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| table::OptionalAssociatedSourceId::AssociatedSourceId(x.0));
5915                        }
5916                    }
5917                }
5918                Ok(Table {
5919                    id: id__.unwrap_or_default(),
5920                    schema_id: schema_id__.unwrap_or_default(),
5921                    database_id: database_id__.unwrap_or_default(),
5922                    name: name__.unwrap_or_default(),
5923                    columns: columns__.unwrap_or_default(),
5924                    pk: pk__.unwrap_or_default(),
5925                    table_type: table_type__.unwrap_or_default(),
5926                    distribution_key: distribution_key__.unwrap_or_default(),
5927                    stream_key: stream_key__.unwrap_or_default(),
5928                    append_only: append_only__.unwrap_or_default(),
5929                    owner: owner__.unwrap_or_default(),
5930                    fragment_id: fragment_id__.unwrap_or_default(),
5931                    vnode_col_index: vnode_col_index__,
5932                    row_id_index: row_id_index__,
5933                    value_indices: value_indices__.unwrap_or_default(),
5934                    definition: definition__.unwrap_or_default(),
5935                    handle_pk_conflict_behavior: handle_pk_conflict_behavior__.unwrap_or_default(),
5936                    read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
5937                    watermark_indices: watermark_indices__.unwrap_or_default(),
5938                    dist_key_in_pk: dist_key_in_pk__.unwrap_or_default(),
5939                    dml_fragment_id: dml_fragment_id__,
5940                    cardinality: cardinality__,
5941                    initialized_at_epoch: initialized_at_epoch__,
5942                    created_at_epoch: created_at_epoch__,
5943                    cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
5944                    stream_job_status: stream_job_status__.unwrap_or_default(),
5945                    create_type: create_type__.unwrap_or_default(),
5946                    description: description__,
5947                    incoming_sinks: incoming_sinks__.unwrap_or_default(),
5948                    initialized_at_cluster_version: initialized_at_cluster_version__,
5949                    created_at_cluster_version: created_at_cluster_version__,
5950                    retention_seconds: retention_seconds__,
5951                    version_column_index: version_column_index__,
5952                    cdc_table_id: cdc_table_id__,
5953                    maybe_vnode_count: maybe_vnode_count__,
5954                    webhook_info: webhook_info__,
5955                    job_id: job_id__,
5956                    engine: engine__,
5957                    clean_watermark_index_in_pk: clean_watermark_index_in_pk__,
5958                    version: version__,
5959                    optional_associated_source_id: optional_associated_source_id__,
5960                })
5961            }
5962        }
5963        deserializer.deserialize_struct("catalog.Table", FIELDS, GeneratedVisitor)
5964    }
5965}
5966impl serde::Serialize for table::Engine {
5967    #[allow(deprecated)]
5968    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5969    where
5970        S: serde::Serializer,
5971    {
5972        let variant = match self {
5973            Self::Unspecified => "ENGINE_UNSPECIFIED",
5974            Self::Hummock => "HUMMOCK",
5975            Self::Iceberg => "ICEBERG",
5976        };
5977        serializer.serialize_str(variant)
5978    }
5979}
5980impl<'de> serde::Deserialize<'de> for table::Engine {
5981    #[allow(deprecated)]
5982    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5983    where
5984        D: serde::Deserializer<'de>,
5985    {
5986        const FIELDS: &[&str] = &[
5987            "ENGINE_UNSPECIFIED",
5988            "HUMMOCK",
5989            "ICEBERG",
5990        ];
5991
5992        struct GeneratedVisitor;
5993
5994        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5995            type Value = table::Engine;
5996
5997            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5998                write!(formatter, "expected one of: {:?}", &FIELDS)
5999            }
6000
6001            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6002            where
6003                E: serde::de::Error,
6004            {
6005                i32::try_from(v)
6006                    .ok()
6007                    .and_then(|x| x.try_into().ok())
6008                    .ok_or_else(|| {
6009                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6010                    })
6011            }
6012
6013            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6014            where
6015                E: serde::de::Error,
6016            {
6017                i32::try_from(v)
6018                    .ok()
6019                    .and_then(|x| x.try_into().ok())
6020                    .ok_or_else(|| {
6021                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6022                    })
6023            }
6024
6025            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6026            where
6027                E: serde::de::Error,
6028            {
6029                match value {
6030                    "ENGINE_UNSPECIFIED" => Ok(table::Engine::Unspecified),
6031                    "HUMMOCK" => Ok(table::Engine::Hummock),
6032                    "ICEBERG" => Ok(table::Engine::Iceberg),
6033                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6034                }
6035            }
6036        }
6037        deserializer.deserialize_any(GeneratedVisitor)
6038    }
6039}
6040impl serde::Serialize for table::TableType {
6041    #[allow(deprecated)]
6042    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6043    where
6044        S: serde::Serializer,
6045    {
6046        let variant = match self {
6047            Self::Unspecified => "UNSPECIFIED",
6048            Self::Table => "TABLE",
6049            Self::MaterializedView => "MATERIALIZED_VIEW",
6050            Self::Index => "INDEX",
6051            Self::Internal => "INTERNAL",
6052        };
6053        serializer.serialize_str(variant)
6054    }
6055}
6056impl<'de> serde::Deserialize<'de> for table::TableType {
6057    #[allow(deprecated)]
6058    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6059    where
6060        D: serde::Deserializer<'de>,
6061    {
6062        const FIELDS: &[&str] = &[
6063            "UNSPECIFIED",
6064            "TABLE",
6065            "MATERIALIZED_VIEW",
6066            "INDEX",
6067            "INTERNAL",
6068        ];
6069
6070        struct GeneratedVisitor;
6071
6072        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6073            type Value = table::TableType;
6074
6075            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6076                write!(formatter, "expected one of: {:?}", &FIELDS)
6077            }
6078
6079            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6080            where
6081                E: serde::de::Error,
6082            {
6083                i32::try_from(v)
6084                    .ok()
6085                    .and_then(|x| x.try_into().ok())
6086                    .ok_or_else(|| {
6087                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6088                    })
6089            }
6090
6091            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6092            where
6093                E: serde::de::Error,
6094            {
6095                i32::try_from(v)
6096                    .ok()
6097                    .and_then(|x| x.try_into().ok())
6098                    .ok_or_else(|| {
6099                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6100                    })
6101            }
6102
6103            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6104            where
6105                E: serde::de::Error,
6106            {
6107                match value {
6108                    "UNSPECIFIED" => Ok(table::TableType::Unspecified),
6109                    "TABLE" => Ok(table::TableType::Table),
6110                    "MATERIALIZED_VIEW" => Ok(table::TableType::MaterializedView),
6111                    "INDEX" => Ok(table::TableType::Index),
6112                    "INTERNAL" => Ok(table::TableType::Internal),
6113                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6114                }
6115            }
6116        }
6117        deserializer.deserialize_any(GeneratedVisitor)
6118    }
6119}
6120impl serde::Serialize for table::TableVersion {
6121    #[allow(deprecated)]
6122    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6123    where
6124        S: serde::Serializer,
6125    {
6126        use serde::ser::SerializeStruct;
6127        let mut len = 0;
6128        if self.version != 0 {
6129            len += 1;
6130        }
6131        if self.next_column_id != 0 {
6132            len += 1;
6133        }
6134        let mut struct_ser = serializer.serialize_struct("catalog.Table.TableVersion", len)?;
6135        if self.version != 0 {
6136            #[allow(clippy::needless_borrow)]
6137            #[allow(clippy::needless_borrows_for_generic_args)]
6138            struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
6139        }
6140        if self.next_column_id != 0 {
6141            struct_ser.serialize_field("nextColumnId", &self.next_column_id)?;
6142        }
6143        struct_ser.end()
6144    }
6145}
6146impl<'de> serde::Deserialize<'de> for table::TableVersion {
6147    #[allow(deprecated)]
6148    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6149    where
6150        D: serde::Deserializer<'de>,
6151    {
6152        const FIELDS: &[&str] = &[
6153            "version",
6154            "next_column_id",
6155            "nextColumnId",
6156        ];
6157
6158        #[allow(clippy::enum_variant_names)]
6159        enum GeneratedField {
6160            Version,
6161            NextColumnId,
6162        }
6163        impl<'de> serde::Deserialize<'de> for GeneratedField {
6164            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6165            where
6166                D: serde::Deserializer<'de>,
6167            {
6168                struct GeneratedVisitor;
6169
6170                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6171                    type Value = GeneratedField;
6172
6173                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6174                        write!(formatter, "expected one of: {:?}", &FIELDS)
6175                    }
6176
6177                    #[allow(unused_variables)]
6178                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6179                    where
6180                        E: serde::de::Error,
6181                    {
6182                        match value {
6183                            "version" => Ok(GeneratedField::Version),
6184                            "nextColumnId" | "next_column_id" => Ok(GeneratedField::NextColumnId),
6185                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6186                        }
6187                    }
6188                }
6189                deserializer.deserialize_identifier(GeneratedVisitor)
6190            }
6191        }
6192        struct GeneratedVisitor;
6193        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6194            type Value = table::TableVersion;
6195
6196            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6197                formatter.write_str("struct catalog.Table.TableVersion")
6198            }
6199
6200            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table::TableVersion, V::Error>
6201                where
6202                    V: serde::de::MapAccess<'de>,
6203            {
6204                let mut version__ = None;
6205                let mut next_column_id__ = None;
6206                while let Some(k) = map_.next_key()? {
6207                    match k {
6208                        GeneratedField::Version => {
6209                            if version__.is_some() {
6210                                return Err(serde::de::Error::duplicate_field("version"));
6211                            }
6212                            version__ = 
6213                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6214                            ;
6215                        }
6216                        GeneratedField::NextColumnId => {
6217                            if next_column_id__.is_some() {
6218                                return Err(serde::de::Error::duplicate_field("nextColumnId"));
6219                            }
6220                            next_column_id__ = 
6221                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6222                            ;
6223                        }
6224                    }
6225                }
6226                Ok(table::TableVersion {
6227                    version: version__.unwrap_or_default(),
6228                    next_column_id: next_column_id__.unwrap_or_default(),
6229                })
6230            }
6231        }
6232        deserializer.deserialize_struct("catalog.Table.TableVersion", FIELDS, GeneratedVisitor)
6233    }
6234}
6235impl serde::Serialize for View {
6236    #[allow(deprecated)]
6237    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6238    where
6239        S: serde::Serializer,
6240    {
6241        use serde::ser::SerializeStruct;
6242        let mut len = 0;
6243        if self.id != 0 {
6244            len += 1;
6245        }
6246        if self.schema_id != 0 {
6247            len += 1;
6248        }
6249        if self.database_id != 0 {
6250            len += 1;
6251        }
6252        if !self.name.is_empty() {
6253            len += 1;
6254        }
6255        if self.owner != 0 {
6256            len += 1;
6257        }
6258        if !self.properties.is_empty() {
6259            len += 1;
6260        }
6261        if !self.sql.is_empty() {
6262            len += 1;
6263        }
6264        if !self.columns.is_empty() {
6265            len += 1;
6266        }
6267        let mut struct_ser = serializer.serialize_struct("catalog.View", len)?;
6268        if self.id != 0 {
6269            struct_ser.serialize_field("id", &self.id)?;
6270        }
6271        if self.schema_id != 0 {
6272            struct_ser.serialize_field("schemaId", &self.schema_id)?;
6273        }
6274        if self.database_id != 0 {
6275            struct_ser.serialize_field("databaseId", &self.database_id)?;
6276        }
6277        if !self.name.is_empty() {
6278            struct_ser.serialize_field("name", &self.name)?;
6279        }
6280        if self.owner != 0 {
6281            struct_ser.serialize_field("owner", &self.owner)?;
6282        }
6283        if !self.properties.is_empty() {
6284            struct_ser.serialize_field("properties", &self.properties)?;
6285        }
6286        if !self.sql.is_empty() {
6287            struct_ser.serialize_field("sql", &self.sql)?;
6288        }
6289        if !self.columns.is_empty() {
6290            struct_ser.serialize_field("columns", &self.columns)?;
6291        }
6292        struct_ser.end()
6293    }
6294}
6295impl<'de> serde::Deserialize<'de> for View {
6296    #[allow(deprecated)]
6297    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6298    where
6299        D: serde::Deserializer<'de>,
6300    {
6301        const FIELDS: &[&str] = &[
6302            "id",
6303            "schema_id",
6304            "schemaId",
6305            "database_id",
6306            "databaseId",
6307            "name",
6308            "owner",
6309            "properties",
6310            "sql",
6311            "columns",
6312        ];
6313
6314        #[allow(clippy::enum_variant_names)]
6315        enum GeneratedField {
6316            Id,
6317            SchemaId,
6318            DatabaseId,
6319            Name,
6320            Owner,
6321            Properties,
6322            Sql,
6323            Columns,
6324        }
6325        impl<'de> serde::Deserialize<'de> for GeneratedField {
6326            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6327            where
6328                D: serde::Deserializer<'de>,
6329            {
6330                struct GeneratedVisitor;
6331
6332                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6333                    type Value = GeneratedField;
6334
6335                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6336                        write!(formatter, "expected one of: {:?}", &FIELDS)
6337                    }
6338
6339                    #[allow(unused_variables)]
6340                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6341                    where
6342                        E: serde::de::Error,
6343                    {
6344                        match value {
6345                            "id" => Ok(GeneratedField::Id),
6346                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
6347                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6348                            "name" => Ok(GeneratedField::Name),
6349                            "owner" => Ok(GeneratedField::Owner),
6350                            "properties" => Ok(GeneratedField::Properties),
6351                            "sql" => Ok(GeneratedField::Sql),
6352                            "columns" => Ok(GeneratedField::Columns),
6353                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6354                        }
6355                    }
6356                }
6357                deserializer.deserialize_identifier(GeneratedVisitor)
6358            }
6359        }
6360        struct GeneratedVisitor;
6361        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6362            type Value = View;
6363
6364            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6365                formatter.write_str("struct catalog.View")
6366            }
6367
6368            fn visit_map<V>(self, mut map_: V) -> std::result::Result<View, V::Error>
6369                where
6370                    V: serde::de::MapAccess<'de>,
6371            {
6372                let mut id__ = None;
6373                let mut schema_id__ = None;
6374                let mut database_id__ = None;
6375                let mut name__ = None;
6376                let mut owner__ = None;
6377                let mut properties__ = None;
6378                let mut sql__ = None;
6379                let mut columns__ = 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::SchemaId => {
6391                            if schema_id__.is_some() {
6392                                return Err(serde::de::Error::duplicate_field("schemaId"));
6393                            }
6394                            schema_id__ = 
6395                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6396                            ;
6397                        }
6398                        GeneratedField::DatabaseId => {
6399                            if database_id__.is_some() {
6400                                return Err(serde::de::Error::duplicate_field("databaseId"));
6401                            }
6402                            database_id__ = 
6403                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6404                            ;
6405                        }
6406                        GeneratedField::Name => {
6407                            if name__.is_some() {
6408                                return Err(serde::de::Error::duplicate_field("name"));
6409                            }
6410                            name__ = Some(map_.next_value()?);
6411                        }
6412                        GeneratedField::Owner => {
6413                            if owner__.is_some() {
6414                                return Err(serde::de::Error::duplicate_field("owner"));
6415                            }
6416                            owner__ = 
6417                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6418                            ;
6419                        }
6420                        GeneratedField::Properties => {
6421                            if properties__.is_some() {
6422                                return Err(serde::de::Error::duplicate_field("properties"));
6423                            }
6424                            properties__ = Some(
6425                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
6426                            );
6427                        }
6428                        GeneratedField::Sql => {
6429                            if sql__.is_some() {
6430                                return Err(serde::de::Error::duplicate_field("sql"));
6431                            }
6432                            sql__ = Some(map_.next_value()?);
6433                        }
6434                        GeneratedField::Columns => {
6435                            if columns__.is_some() {
6436                                return Err(serde::de::Error::duplicate_field("columns"));
6437                            }
6438                            columns__ = Some(map_.next_value()?);
6439                        }
6440                    }
6441                }
6442                Ok(View {
6443                    id: id__.unwrap_or_default(),
6444                    schema_id: schema_id__.unwrap_or_default(),
6445                    database_id: database_id__.unwrap_or_default(),
6446                    name: name__.unwrap_or_default(),
6447                    owner: owner__.unwrap_or_default(),
6448                    properties: properties__.unwrap_or_default(),
6449                    sql: sql__.unwrap_or_default(),
6450                    columns: columns__.unwrap_or_default(),
6451                })
6452            }
6453        }
6454        deserializer.deserialize_struct("catalog.View", FIELDS, GeneratedVisitor)
6455    }
6456}
6457impl serde::Serialize for WatermarkDesc {
6458    #[allow(deprecated)]
6459    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6460    where
6461        S: serde::Serializer,
6462    {
6463        use serde::ser::SerializeStruct;
6464        let mut len = 0;
6465        if self.watermark_idx != 0 {
6466            len += 1;
6467        }
6468        if self.expr.is_some() {
6469            len += 1;
6470        }
6471        let mut struct_ser = serializer.serialize_struct("catalog.WatermarkDesc", len)?;
6472        if self.watermark_idx != 0 {
6473            struct_ser.serialize_field("watermarkIdx", &self.watermark_idx)?;
6474        }
6475        if let Some(v) = self.expr.as_ref() {
6476            struct_ser.serialize_field("expr", v)?;
6477        }
6478        struct_ser.end()
6479    }
6480}
6481impl<'de> serde::Deserialize<'de> for WatermarkDesc {
6482    #[allow(deprecated)]
6483    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6484    where
6485        D: serde::Deserializer<'de>,
6486    {
6487        const FIELDS: &[&str] = &[
6488            "watermark_idx",
6489            "watermarkIdx",
6490            "expr",
6491        ];
6492
6493        #[allow(clippy::enum_variant_names)]
6494        enum GeneratedField {
6495            WatermarkIdx,
6496            Expr,
6497        }
6498        impl<'de> serde::Deserialize<'de> for GeneratedField {
6499            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6500            where
6501                D: serde::Deserializer<'de>,
6502            {
6503                struct GeneratedVisitor;
6504
6505                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6506                    type Value = GeneratedField;
6507
6508                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6509                        write!(formatter, "expected one of: {:?}", &FIELDS)
6510                    }
6511
6512                    #[allow(unused_variables)]
6513                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6514                    where
6515                        E: serde::de::Error,
6516                    {
6517                        match value {
6518                            "watermarkIdx" | "watermark_idx" => Ok(GeneratedField::WatermarkIdx),
6519                            "expr" => Ok(GeneratedField::Expr),
6520                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6521                        }
6522                    }
6523                }
6524                deserializer.deserialize_identifier(GeneratedVisitor)
6525            }
6526        }
6527        struct GeneratedVisitor;
6528        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6529            type Value = WatermarkDesc;
6530
6531            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6532                formatter.write_str("struct catalog.WatermarkDesc")
6533            }
6534
6535            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkDesc, V::Error>
6536                where
6537                    V: serde::de::MapAccess<'de>,
6538            {
6539                let mut watermark_idx__ = None;
6540                let mut expr__ = None;
6541                while let Some(k) = map_.next_key()? {
6542                    match k {
6543                        GeneratedField::WatermarkIdx => {
6544                            if watermark_idx__.is_some() {
6545                                return Err(serde::de::Error::duplicate_field("watermarkIdx"));
6546                            }
6547                            watermark_idx__ = 
6548                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6549                            ;
6550                        }
6551                        GeneratedField::Expr => {
6552                            if expr__.is_some() {
6553                                return Err(serde::de::Error::duplicate_field("expr"));
6554                            }
6555                            expr__ = map_.next_value()?;
6556                        }
6557                    }
6558                }
6559                Ok(WatermarkDesc {
6560                    watermark_idx: watermark_idx__.unwrap_or_default(),
6561                    expr: expr__,
6562                })
6563            }
6564        }
6565        deserializer.deserialize_struct("catalog.WatermarkDesc", FIELDS, GeneratedVisitor)
6566    }
6567}
6568impl serde::Serialize for WebhookSourceInfo {
6569    #[allow(deprecated)]
6570    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6571    where
6572        S: serde::Serializer,
6573    {
6574        use serde::ser::SerializeStruct;
6575        let mut len = 0;
6576        if self.secret_ref.is_some() {
6577            len += 1;
6578        }
6579        if self.signature_expr.is_some() {
6580            len += 1;
6581        }
6582        if self.wait_for_persistence {
6583            len += 1;
6584        }
6585        if self.is_batched {
6586            len += 1;
6587        }
6588        let mut struct_ser = serializer.serialize_struct("catalog.WebhookSourceInfo", len)?;
6589        if let Some(v) = self.secret_ref.as_ref() {
6590            struct_ser.serialize_field("secretRef", v)?;
6591        }
6592        if let Some(v) = self.signature_expr.as_ref() {
6593            struct_ser.serialize_field("signatureExpr", v)?;
6594        }
6595        if self.wait_for_persistence {
6596            struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
6597        }
6598        if self.is_batched {
6599            struct_ser.serialize_field("isBatched", &self.is_batched)?;
6600        }
6601        struct_ser.end()
6602    }
6603}
6604impl<'de> serde::Deserialize<'de> for WebhookSourceInfo {
6605    #[allow(deprecated)]
6606    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6607    where
6608        D: serde::Deserializer<'de>,
6609    {
6610        const FIELDS: &[&str] = &[
6611            "secret_ref",
6612            "secretRef",
6613            "signature_expr",
6614            "signatureExpr",
6615            "wait_for_persistence",
6616            "waitForPersistence",
6617            "is_batched",
6618            "isBatched",
6619        ];
6620
6621        #[allow(clippy::enum_variant_names)]
6622        enum GeneratedField {
6623            SecretRef,
6624            SignatureExpr,
6625            WaitForPersistence,
6626            IsBatched,
6627        }
6628        impl<'de> serde::Deserialize<'de> for GeneratedField {
6629            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6630            where
6631                D: serde::Deserializer<'de>,
6632            {
6633                struct GeneratedVisitor;
6634
6635                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6636                    type Value = GeneratedField;
6637
6638                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6639                        write!(formatter, "expected one of: {:?}", &FIELDS)
6640                    }
6641
6642                    #[allow(unused_variables)]
6643                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6644                    where
6645                        E: serde::de::Error,
6646                    {
6647                        match value {
6648                            "secretRef" | "secret_ref" => Ok(GeneratedField::SecretRef),
6649                            "signatureExpr" | "signature_expr" => Ok(GeneratedField::SignatureExpr),
6650                            "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
6651                            "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
6652                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6653                        }
6654                    }
6655                }
6656                deserializer.deserialize_identifier(GeneratedVisitor)
6657            }
6658        }
6659        struct GeneratedVisitor;
6660        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6661            type Value = WebhookSourceInfo;
6662
6663            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6664                formatter.write_str("struct catalog.WebhookSourceInfo")
6665            }
6666
6667            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WebhookSourceInfo, V::Error>
6668                where
6669                    V: serde::de::MapAccess<'de>,
6670            {
6671                let mut secret_ref__ = None;
6672                let mut signature_expr__ = None;
6673                let mut wait_for_persistence__ = None;
6674                let mut is_batched__ = None;
6675                while let Some(k) = map_.next_key()? {
6676                    match k {
6677                        GeneratedField::SecretRef => {
6678                            if secret_ref__.is_some() {
6679                                return Err(serde::de::Error::duplicate_field("secretRef"));
6680                            }
6681                            secret_ref__ = map_.next_value()?;
6682                        }
6683                        GeneratedField::SignatureExpr => {
6684                            if signature_expr__.is_some() {
6685                                return Err(serde::de::Error::duplicate_field("signatureExpr"));
6686                            }
6687                            signature_expr__ = map_.next_value()?;
6688                        }
6689                        GeneratedField::WaitForPersistence => {
6690                            if wait_for_persistence__.is_some() {
6691                                return Err(serde::de::Error::duplicate_field("waitForPersistence"));
6692                            }
6693                            wait_for_persistence__ = Some(map_.next_value()?);
6694                        }
6695                        GeneratedField::IsBatched => {
6696                            if is_batched__.is_some() {
6697                                return Err(serde::de::Error::duplicate_field("isBatched"));
6698                            }
6699                            is_batched__ = Some(map_.next_value()?);
6700                        }
6701                    }
6702                }
6703                Ok(WebhookSourceInfo {
6704                    secret_ref: secret_ref__,
6705                    signature_expr: signature_expr__,
6706                    wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
6707                    is_batched: is_batched__.unwrap_or_default(),
6708                })
6709            }
6710        }
6711        deserializer.deserialize_struct("catalog.WebhookSourceInfo", FIELDS, GeneratedVisitor)
6712    }
6713}