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 FlatIndexConfig {
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 len = 0;
1220        let struct_ser = serializer.serialize_struct("catalog.FlatIndexConfig", len)?;
1221        struct_ser.end()
1222    }
1223}
1224impl<'de> serde::Deserialize<'de> for FlatIndexConfig {
1225    #[allow(deprecated)]
1226    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1227    where
1228        D: serde::Deserializer<'de>,
1229    {
1230        const FIELDS: &[&str] = &[
1231        ];
1232
1233        #[allow(clippy::enum_variant_names)]
1234        enum GeneratedField {
1235        }
1236        impl<'de> serde::Deserialize<'de> for GeneratedField {
1237            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1238            where
1239                D: serde::Deserializer<'de>,
1240            {
1241                struct GeneratedVisitor;
1242
1243                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1244                    type Value = GeneratedField;
1245
1246                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1247                        write!(formatter, "expected one of: {:?}", &FIELDS)
1248                    }
1249
1250                    #[allow(unused_variables)]
1251                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1252                    where
1253                        E: serde::de::Error,
1254                    {
1255                            Err(serde::de::Error::unknown_field(value, FIELDS))
1256                    }
1257                }
1258                deserializer.deserialize_identifier(GeneratedVisitor)
1259            }
1260        }
1261        struct GeneratedVisitor;
1262        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1263            type Value = FlatIndexConfig;
1264
1265            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1266                formatter.write_str("struct catalog.FlatIndexConfig")
1267            }
1268
1269            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexConfig, V::Error>
1270                where
1271                    V: serde::de::MapAccess<'de>,
1272            {
1273                while map_.next_key::<GeneratedField>()?.is_some() {
1274                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1275                }
1276                Ok(FlatIndexConfig {
1277                })
1278            }
1279        }
1280        deserializer.deserialize_struct("catalog.FlatIndexConfig", FIELDS, GeneratedVisitor)
1281    }
1282}
1283impl serde::Serialize for Function {
1284    #[allow(deprecated)]
1285    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1286    where
1287        S: serde::Serializer,
1288    {
1289        use serde::ser::SerializeStruct;
1290        let mut len = 0;
1291        if self.id != 0 {
1292            len += 1;
1293        }
1294        if self.schema_id != 0 {
1295            len += 1;
1296        }
1297        if self.database_id != 0 {
1298            len += 1;
1299        }
1300        if !self.name.is_empty() {
1301            len += 1;
1302        }
1303        if self.owner != 0 {
1304            len += 1;
1305        }
1306        if !self.arg_names.is_empty() {
1307            len += 1;
1308        }
1309        if !self.arg_types.is_empty() {
1310            len += 1;
1311        }
1312        if self.return_type.is_some() {
1313            len += 1;
1314        }
1315        if !self.language.is_empty() {
1316            len += 1;
1317        }
1318        if self.link.is_some() {
1319            len += 1;
1320        }
1321        if self.name_in_runtime.is_some() {
1322            len += 1;
1323        }
1324        if self.body.is_some() {
1325            len += 1;
1326        }
1327        if self.compressed_binary.is_some() {
1328            len += 1;
1329        }
1330        if self.always_retry_on_network_error {
1331            len += 1;
1332        }
1333        if self.runtime.is_some() {
1334            len += 1;
1335        }
1336        if self.is_async.is_some() {
1337            len += 1;
1338        }
1339        if self.is_batched.is_some() {
1340            len += 1;
1341        }
1342        if self.created_at_epoch.is_some() {
1343            len += 1;
1344        }
1345        if self.created_at_cluster_version.is_some() {
1346            len += 1;
1347        }
1348        if self.kind.is_some() {
1349            len += 1;
1350        }
1351        let mut struct_ser = serializer.serialize_struct("catalog.Function", len)?;
1352        if self.id != 0 {
1353            struct_ser.serialize_field("id", &self.id)?;
1354        }
1355        if self.schema_id != 0 {
1356            struct_ser.serialize_field("schemaId", &self.schema_id)?;
1357        }
1358        if self.database_id != 0 {
1359            struct_ser.serialize_field("databaseId", &self.database_id)?;
1360        }
1361        if !self.name.is_empty() {
1362            struct_ser.serialize_field("name", &self.name)?;
1363        }
1364        if self.owner != 0 {
1365            struct_ser.serialize_field("owner", &self.owner)?;
1366        }
1367        if !self.arg_names.is_empty() {
1368            struct_ser.serialize_field("argNames", &self.arg_names)?;
1369        }
1370        if !self.arg_types.is_empty() {
1371            struct_ser.serialize_field("argTypes", &self.arg_types)?;
1372        }
1373        if let Some(v) = self.return_type.as_ref() {
1374            struct_ser.serialize_field("returnType", v)?;
1375        }
1376        if !self.language.is_empty() {
1377            struct_ser.serialize_field("language", &self.language)?;
1378        }
1379        if let Some(v) = self.link.as_ref() {
1380            struct_ser.serialize_field("link", v)?;
1381        }
1382        if let Some(v) = self.name_in_runtime.as_ref() {
1383            struct_ser.serialize_field("nameInRuntime", v)?;
1384        }
1385        if let Some(v) = self.body.as_ref() {
1386            struct_ser.serialize_field("body", v)?;
1387        }
1388        if let Some(v) = self.compressed_binary.as_ref() {
1389            #[allow(clippy::needless_borrow)]
1390            #[allow(clippy::needless_borrows_for_generic_args)]
1391            struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
1392        }
1393        if self.always_retry_on_network_error {
1394            struct_ser.serialize_field("alwaysRetryOnNetworkError", &self.always_retry_on_network_error)?;
1395        }
1396        if let Some(v) = self.runtime.as_ref() {
1397            struct_ser.serialize_field("runtime", v)?;
1398        }
1399        if let Some(v) = self.is_async.as_ref() {
1400            struct_ser.serialize_field("isAsync", v)?;
1401        }
1402        if let Some(v) = self.is_batched.as_ref() {
1403            struct_ser.serialize_field("isBatched", v)?;
1404        }
1405        if let Some(v) = self.created_at_epoch.as_ref() {
1406            #[allow(clippy::needless_borrow)]
1407            #[allow(clippy::needless_borrows_for_generic_args)]
1408            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
1409        }
1410        if let Some(v) = self.created_at_cluster_version.as_ref() {
1411            struct_ser.serialize_field("createdAtClusterVersion", v)?;
1412        }
1413        if let Some(v) = self.kind.as_ref() {
1414            match v {
1415                function::Kind::Scalar(v) => {
1416                    struct_ser.serialize_field("scalar", v)?;
1417                }
1418                function::Kind::Table(v) => {
1419                    struct_ser.serialize_field("table", v)?;
1420                }
1421                function::Kind::Aggregate(v) => {
1422                    struct_ser.serialize_field("aggregate", v)?;
1423                }
1424            }
1425        }
1426        struct_ser.end()
1427    }
1428}
1429impl<'de> serde::Deserialize<'de> for Function {
1430    #[allow(deprecated)]
1431    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1432    where
1433        D: serde::Deserializer<'de>,
1434    {
1435        const FIELDS: &[&str] = &[
1436            "id",
1437            "schema_id",
1438            "schemaId",
1439            "database_id",
1440            "databaseId",
1441            "name",
1442            "owner",
1443            "arg_names",
1444            "argNames",
1445            "arg_types",
1446            "argTypes",
1447            "return_type",
1448            "returnType",
1449            "language",
1450            "link",
1451            "name_in_runtime",
1452            "nameInRuntime",
1453            "body",
1454            "compressed_binary",
1455            "compressedBinary",
1456            "always_retry_on_network_error",
1457            "alwaysRetryOnNetworkError",
1458            "runtime",
1459            "is_async",
1460            "isAsync",
1461            "is_batched",
1462            "isBatched",
1463            "created_at_epoch",
1464            "createdAtEpoch",
1465            "created_at_cluster_version",
1466            "createdAtClusterVersion",
1467            "scalar",
1468            "table",
1469            "aggregate",
1470        ];
1471
1472        #[allow(clippy::enum_variant_names)]
1473        enum GeneratedField {
1474            Id,
1475            SchemaId,
1476            DatabaseId,
1477            Name,
1478            Owner,
1479            ArgNames,
1480            ArgTypes,
1481            ReturnType,
1482            Language,
1483            Link,
1484            NameInRuntime,
1485            Body,
1486            CompressedBinary,
1487            AlwaysRetryOnNetworkError,
1488            Runtime,
1489            IsAsync,
1490            IsBatched,
1491            CreatedAtEpoch,
1492            CreatedAtClusterVersion,
1493            Scalar,
1494            Table,
1495            Aggregate,
1496        }
1497        impl<'de> serde::Deserialize<'de> for GeneratedField {
1498            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1499            where
1500                D: serde::Deserializer<'de>,
1501            {
1502                struct GeneratedVisitor;
1503
1504                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1505                    type Value = GeneratedField;
1506
1507                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1508                        write!(formatter, "expected one of: {:?}", &FIELDS)
1509                    }
1510
1511                    #[allow(unused_variables)]
1512                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1513                    where
1514                        E: serde::de::Error,
1515                    {
1516                        match value {
1517                            "id" => Ok(GeneratedField::Id),
1518                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1519                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1520                            "name" => Ok(GeneratedField::Name),
1521                            "owner" => Ok(GeneratedField::Owner),
1522                            "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
1523                            "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
1524                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
1525                            "language" => Ok(GeneratedField::Language),
1526                            "link" => Ok(GeneratedField::Link),
1527                            "nameInRuntime" | "name_in_runtime" => Ok(GeneratedField::NameInRuntime),
1528                            "body" => Ok(GeneratedField::Body),
1529                            "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
1530                            "alwaysRetryOnNetworkError" | "always_retry_on_network_error" => Ok(GeneratedField::AlwaysRetryOnNetworkError),
1531                            "runtime" => Ok(GeneratedField::Runtime),
1532                            "isAsync" | "is_async" => Ok(GeneratedField::IsAsync),
1533                            "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
1534                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
1535                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
1536                            "scalar" => Ok(GeneratedField::Scalar),
1537                            "table" => Ok(GeneratedField::Table),
1538                            "aggregate" => Ok(GeneratedField::Aggregate),
1539                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1540                        }
1541                    }
1542                }
1543                deserializer.deserialize_identifier(GeneratedVisitor)
1544            }
1545        }
1546        struct GeneratedVisitor;
1547        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1548            type Value = Function;
1549
1550            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1551                formatter.write_str("struct catalog.Function")
1552            }
1553
1554            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Function, V::Error>
1555                where
1556                    V: serde::de::MapAccess<'de>,
1557            {
1558                let mut id__ = None;
1559                let mut schema_id__ = None;
1560                let mut database_id__ = None;
1561                let mut name__ = None;
1562                let mut owner__ = None;
1563                let mut arg_names__ = None;
1564                let mut arg_types__ = None;
1565                let mut return_type__ = None;
1566                let mut language__ = None;
1567                let mut link__ = None;
1568                let mut name_in_runtime__ = None;
1569                let mut body__ = None;
1570                let mut compressed_binary__ = None;
1571                let mut always_retry_on_network_error__ = None;
1572                let mut runtime__ = None;
1573                let mut is_async__ = None;
1574                let mut is_batched__ = None;
1575                let mut created_at_epoch__ = None;
1576                let mut created_at_cluster_version__ = None;
1577                let mut kind__ = None;
1578                while let Some(k) = map_.next_key()? {
1579                    match k {
1580                        GeneratedField::Id => {
1581                            if id__.is_some() {
1582                                return Err(serde::de::Error::duplicate_field("id"));
1583                            }
1584                            id__ = 
1585                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1586                            ;
1587                        }
1588                        GeneratedField::SchemaId => {
1589                            if schema_id__.is_some() {
1590                                return Err(serde::de::Error::duplicate_field("schemaId"));
1591                            }
1592                            schema_id__ = 
1593                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1594                            ;
1595                        }
1596                        GeneratedField::DatabaseId => {
1597                            if database_id__.is_some() {
1598                                return Err(serde::de::Error::duplicate_field("databaseId"));
1599                            }
1600                            database_id__ = 
1601                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1602                            ;
1603                        }
1604                        GeneratedField::Name => {
1605                            if name__.is_some() {
1606                                return Err(serde::de::Error::duplicate_field("name"));
1607                            }
1608                            name__ = Some(map_.next_value()?);
1609                        }
1610                        GeneratedField::Owner => {
1611                            if owner__.is_some() {
1612                                return Err(serde::de::Error::duplicate_field("owner"));
1613                            }
1614                            owner__ = 
1615                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1616                            ;
1617                        }
1618                        GeneratedField::ArgNames => {
1619                            if arg_names__.is_some() {
1620                                return Err(serde::de::Error::duplicate_field("argNames"));
1621                            }
1622                            arg_names__ = Some(map_.next_value()?);
1623                        }
1624                        GeneratedField::ArgTypes => {
1625                            if arg_types__.is_some() {
1626                                return Err(serde::de::Error::duplicate_field("argTypes"));
1627                            }
1628                            arg_types__ = Some(map_.next_value()?);
1629                        }
1630                        GeneratedField::ReturnType => {
1631                            if return_type__.is_some() {
1632                                return Err(serde::de::Error::duplicate_field("returnType"));
1633                            }
1634                            return_type__ = map_.next_value()?;
1635                        }
1636                        GeneratedField::Language => {
1637                            if language__.is_some() {
1638                                return Err(serde::de::Error::duplicate_field("language"));
1639                            }
1640                            language__ = Some(map_.next_value()?);
1641                        }
1642                        GeneratedField::Link => {
1643                            if link__.is_some() {
1644                                return Err(serde::de::Error::duplicate_field("link"));
1645                            }
1646                            link__ = map_.next_value()?;
1647                        }
1648                        GeneratedField::NameInRuntime => {
1649                            if name_in_runtime__.is_some() {
1650                                return Err(serde::de::Error::duplicate_field("nameInRuntime"));
1651                            }
1652                            name_in_runtime__ = map_.next_value()?;
1653                        }
1654                        GeneratedField::Body => {
1655                            if body__.is_some() {
1656                                return Err(serde::de::Error::duplicate_field("body"));
1657                            }
1658                            body__ = map_.next_value()?;
1659                        }
1660                        GeneratedField::CompressedBinary => {
1661                            if compressed_binary__.is_some() {
1662                                return Err(serde::de::Error::duplicate_field("compressedBinary"));
1663                            }
1664                            compressed_binary__ = 
1665                                map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
1666                            ;
1667                        }
1668                        GeneratedField::AlwaysRetryOnNetworkError => {
1669                            if always_retry_on_network_error__.is_some() {
1670                                return Err(serde::de::Error::duplicate_field("alwaysRetryOnNetworkError"));
1671                            }
1672                            always_retry_on_network_error__ = Some(map_.next_value()?);
1673                        }
1674                        GeneratedField::Runtime => {
1675                            if runtime__.is_some() {
1676                                return Err(serde::de::Error::duplicate_field("runtime"));
1677                            }
1678                            runtime__ = map_.next_value()?;
1679                        }
1680                        GeneratedField::IsAsync => {
1681                            if is_async__.is_some() {
1682                                return Err(serde::de::Error::duplicate_field("isAsync"));
1683                            }
1684                            is_async__ = map_.next_value()?;
1685                        }
1686                        GeneratedField::IsBatched => {
1687                            if is_batched__.is_some() {
1688                                return Err(serde::de::Error::duplicate_field("isBatched"));
1689                            }
1690                            is_batched__ = map_.next_value()?;
1691                        }
1692                        GeneratedField::CreatedAtEpoch => {
1693                            if created_at_epoch__.is_some() {
1694                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
1695                            }
1696                            created_at_epoch__ = 
1697                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1698                            ;
1699                        }
1700                        GeneratedField::CreatedAtClusterVersion => {
1701                            if created_at_cluster_version__.is_some() {
1702                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
1703                            }
1704                            created_at_cluster_version__ = map_.next_value()?;
1705                        }
1706                        GeneratedField::Scalar => {
1707                            if kind__.is_some() {
1708                                return Err(serde::de::Error::duplicate_field("scalar"));
1709                            }
1710                            kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Scalar)
1711;
1712                        }
1713                        GeneratedField::Table => {
1714                            if kind__.is_some() {
1715                                return Err(serde::de::Error::duplicate_field("table"));
1716                            }
1717                            kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Table)
1718;
1719                        }
1720                        GeneratedField::Aggregate => {
1721                            if kind__.is_some() {
1722                                return Err(serde::de::Error::duplicate_field("aggregate"));
1723                            }
1724                            kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Aggregate)
1725;
1726                        }
1727                    }
1728                }
1729                Ok(Function {
1730                    id: id__.unwrap_or_default(),
1731                    schema_id: schema_id__.unwrap_or_default(),
1732                    database_id: database_id__.unwrap_or_default(),
1733                    name: name__.unwrap_or_default(),
1734                    owner: owner__.unwrap_or_default(),
1735                    arg_names: arg_names__.unwrap_or_default(),
1736                    arg_types: arg_types__.unwrap_or_default(),
1737                    return_type: return_type__,
1738                    language: language__.unwrap_or_default(),
1739                    link: link__,
1740                    name_in_runtime: name_in_runtime__,
1741                    body: body__,
1742                    compressed_binary: compressed_binary__,
1743                    always_retry_on_network_error: always_retry_on_network_error__.unwrap_or_default(),
1744                    runtime: runtime__,
1745                    is_async: is_async__,
1746                    is_batched: is_batched__,
1747                    created_at_epoch: created_at_epoch__,
1748                    created_at_cluster_version: created_at_cluster_version__,
1749                    kind: kind__,
1750                })
1751            }
1752        }
1753        deserializer.deserialize_struct("catalog.Function", FIELDS, GeneratedVisitor)
1754    }
1755}
1756impl serde::Serialize for function::AggregateFunction {
1757    #[allow(deprecated)]
1758    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1759    where
1760        S: serde::Serializer,
1761    {
1762        use serde::ser::SerializeStruct;
1763        let len = 0;
1764        let struct_ser = serializer.serialize_struct("catalog.Function.AggregateFunction", len)?;
1765        struct_ser.end()
1766    }
1767}
1768impl<'de> serde::Deserialize<'de> for function::AggregateFunction {
1769    #[allow(deprecated)]
1770    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1771    where
1772        D: serde::Deserializer<'de>,
1773    {
1774        const FIELDS: &[&str] = &[
1775        ];
1776
1777        #[allow(clippy::enum_variant_names)]
1778        enum GeneratedField {
1779        }
1780        impl<'de> serde::Deserialize<'de> for GeneratedField {
1781            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1782            where
1783                D: serde::Deserializer<'de>,
1784            {
1785                struct GeneratedVisitor;
1786
1787                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1788                    type Value = GeneratedField;
1789
1790                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1791                        write!(formatter, "expected one of: {:?}", &FIELDS)
1792                    }
1793
1794                    #[allow(unused_variables)]
1795                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1796                    where
1797                        E: serde::de::Error,
1798                    {
1799                            Err(serde::de::Error::unknown_field(value, FIELDS))
1800                    }
1801                }
1802                deserializer.deserialize_identifier(GeneratedVisitor)
1803            }
1804        }
1805        struct GeneratedVisitor;
1806        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1807            type Value = function::AggregateFunction;
1808
1809            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1810                formatter.write_str("struct catalog.Function.AggregateFunction")
1811            }
1812
1813            fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::AggregateFunction, V::Error>
1814                where
1815                    V: serde::de::MapAccess<'de>,
1816            {
1817                while map_.next_key::<GeneratedField>()?.is_some() {
1818                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1819                }
1820                Ok(function::AggregateFunction {
1821                })
1822            }
1823        }
1824        deserializer.deserialize_struct("catalog.Function.AggregateFunction", FIELDS, GeneratedVisitor)
1825    }
1826}
1827impl serde::Serialize for function::ScalarFunction {
1828    #[allow(deprecated)]
1829    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1830    where
1831        S: serde::Serializer,
1832    {
1833        use serde::ser::SerializeStruct;
1834        let len = 0;
1835        let struct_ser = serializer.serialize_struct("catalog.Function.ScalarFunction", len)?;
1836        struct_ser.end()
1837    }
1838}
1839impl<'de> serde::Deserialize<'de> for function::ScalarFunction {
1840    #[allow(deprecated)]
1841    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1842    where
1843        D: serde::Deserializer<'de>,
1844    {
1845        const FIELDS: &[&str] = &[
1846        ];
1847
1848        #[allow(clippy::enum_variant_names)]
1849        enum GeneratedField {
1850        }
1851        impl<'de> serde::Deserialize<'de> for GeneratedField {
1852            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1853            where
1854                D: serde::Deserializer<'de>,
1855            {
1856                struct GeneratedVisitor;
1857
1858                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1859                    type Value = GeneratedField;
1860
1861                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1862                        write!(formatter, "expected one of: {:?}", &FIELDS)
1863                    }
1864
1865                    #[allow(unused_variables)]
1866                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1867                    where
1868                        E: serde::de::Error,
1869                    {
1870                            Err(serde::de::Error::unknown_field(value, FIELDS))
1871                    }
1872                }
1873                deserializer.deserialize_identifier(GeneratedVisitor)
1874            }
1875        }
1876        struct GeneratedVisitor;
1877        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1878            type Value = function::ScalarFunction;
1879
1880            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1881                formatter.write_str("struct catalog.Function.ScalarFunction")
1882            }
1883
1884            fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::ScalarFunction, V::Error>
1885                where
1886                    V: serde::de::MapAccess<'de>,
1887            {
1888                while map_.next_key::<GeneratedField>()?.is_some() {
1889                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1890                }
1891                Ok(function::ScalarFunction {
1892                })
1893            }
1894        }
1895        deserializer.deserialize_struct("catalog.Function.ScalarFunction", FIELDS, GeneratedVisitor)
1896    }
1897}
1898impl serde::Serialize for function::TableFunction {
1899    #[allow(deprecated)]
1900    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1901    where
1902        S: serde::Serializer,
1903    {
1904        use serde::ser::SerializeStruct;
1905        let len = 0;
1906        let struct_ser = serializer.serialize_struct("catalog.Function.TableFunction", len)?;
1907        struct_ser.end()
1908    }
1909}
1910impl<'de> serde::Deserialize<'de> for function::TableFunction {
1911    #[allow(deprecated)]
1912    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1913    where
1914        D: serde::Deserializer<'de>,
1915    {
1916        const FIELDS: &[&str] = &[
1917        ];
1918
1919        #[allow(clippy::enum_variant_names)]
1920        enum GeneratedField {
1921        }
1922        impl<'de> serde::Deserialize<'de> for GeneratedField {
1923            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1924            where
1925                D: serde::Deserializer<'de>,
1926            {
1927                struct GeneratedVisitor;
1928
1929                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1930                    type Value = GeneratedField;
1931
1932                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1933                        write!(formatter, "expected one of: {:?}", &FIELDS)
1934                    }
1935
1936                    #[allow(unused_variables)]
1937                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1938                    where
1939                        E: serde::de::Error,
1940                    {
1941                            Err(serde::de::Error::unknown_field(value, FIELDS))
1942                    }
1943                }
1944                deserializer.deserialize_identifier(GeneratedVisitor)
1945            }
1946        }
1947        struct GeneratedVisitor;
1948        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1949            type Value = function::TableFunction;
1950
1951            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1952                formatter.write_str("struct catalog.Function.TableFunction")
1953            }
1954
1955            fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::TableFunction, V::Error>
1956                where
1957                    V: serde::de::MapAccess<'de>,
1958            {
1959                while map_.next_key::<GeneratedField>()?.is_some() {
1960                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1961                }
1962                Ok(function::TableFunction {
1963                })
1964            }
1965        }
1966        deserializer.deserialize_struct("catalog.Function.TableFunction", FIELDS, GeneratedVisitor)
1967    }
1968}
1969impl serde::Serialize for HandleConflictBehavior {
1970    #[allow(deprecated)]
1971    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1972    where
1973        S: serde::Serializer,
1974    {
1975        let variant = match self {
1976            Self::Unspecified => "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED",
1977            Self::Overwrite => "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE",
1978            Self::Ignore => "HANDLE_CONFLICT_BEHAVIOR_IGNORE",
1979            Self::NoCheck => "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK",
1980            Self::DoUpdateIfNotNull => "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL",
1981        };
1982        serializer.serialize_str(variant)
1983    }
1984}
1985impl<'de> serde::Deserialize<'de> for HandleConflictBehavior {
1986    #[allow(deprecated)]
1987    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1988    where
1989        D: serde::Deserializer<'de>,
1990    {
1991        const FIELDS: &[&str] = &[
1992            "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED",
1993            "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE",
1994            "HANDLE_CONFLICT_BEHAVIOR_IGNORE",
1995            "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK",
1996            "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL",
1997        ];
1998
1999        struct GeneratedVisitor;
2000
2001        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2002            type Value = HandleConflictBehavior;
2003
2004            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2005                write!(formatter, "expected one of: {:?}", &FIELDS)
2006            }
2007
2008            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2009            where
2010                E: serde::de::Error,
2011            {
2012                i32::try_from(v)
2013                    .ok()
2014                    .and_then(|x| x.try_into().ok())
2015                    .ok_or_else(|| {
2016                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2017                    })
2018            }
2019
2020            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2021            where
2022                E: serde::de::Error,
2023            {
2024                i32::try_from(v)
2025                    .ok()
2026                    .and_then(|x| x.try_into().ok())
2027                    .ok_or_else(|| {
2028                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2029                    })
2030            }
2031
2032            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2033            where
2034                E: serde::de::Error,
2035            {
2036                match value {
2037                    "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED" => Ok(HandleConflictBehavior::Unspecified),
2038                    "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE" => Ok(HandleConflictBehavior::Overwrite),
2039                    "HANDLE_CONFLICT_BEHAVIOR_IGNORE" => Ok(HandleConflictBehavior::Ignore),
2040                    "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK" => Ok(HandleConflictBehavior::NoCheck),
2041                    "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL" => Ok(HandleConflictBehavior::DoUpdateIfNotNull),
2042                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2043                }
2044            }
2045        }
2046        deserializer.deserialize_any(GeneratedVisitor)
2047    }
2048}
2049impl serde::Serialize for HnswFlatIndexConfig {
2050    #[allow(deprecated)]
2051    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2052    where
2053        S: serde::Serializer,
2054    {
2055        use serde::ser::SerializeStruct;
2056        let mut len = 0;
2057        if self.m != 0 {
2058            len += 1;
2059        }
2060        if self.ef_construction != 0 {
2061            len += 1;
2062        }
2063        if self.max_level != 0 {
2064            len += 1;
2065        }
2066        let mut struct_ser = serializer.serialize_struct("catalog.HnswFlatIndexConfig", len)?;
2067        if self.m != 0 {
2068            struct_ser.serialize_field("m", &self.m)?;
2069        }
2070        if self.ef_construction != 0 {
2071            struct_ser.serialize_field("efConstruction", &self.ef_construction)?;
2072        }
2073        if self.max_level != 0 {
2074            struct_ser.serialize_field("maxLevel", &self.max_level)?;
2075        }
2076        struct_ser.end()
2077    }
2078}
2079impl<'de> serde::Deserialize<'de> for HnswFlatIndexConfig {
2080    #[allow(deprecated)]
2081    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2082    where
2083        D: serde::Deserializer<'de>,
2084    {
2085        const FIELDS: &[&str] = &[
2086            "m",
2087            "ef_construction",
2088            "efConstruction",
2089            "max_level",
2090            "maxLevel",
2091        ];
2092
2093        #[allow(clippy::enum_variant_names)]
2094        enum GeneratedField {
2095            M,
2096            EfConstruction,
2097            MaxLevel,
2098        }
2099        impl<'de> serde::Deserialize<'de> for GeneratedField {
2100            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2101            where
2102                D: serde::Deserializer<'de>,
2103            {
2104                struct GeneratedVisitor;
2105
2106                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2107                    type Value = GeneratedField;
2108
2109                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2110                        write!(formatter, "expected one of: {:?}", &FIELDS)
2111                    }
2112
2113                    #[allow(unused_variables)]
2114                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2115                    where
2116                        E: serde::de::Error,
2117                    {
2118                        match value {
2119                            "m" => Ok(GeneratedField::M),
2120                            "efConstruction" | "ef_construction" => Ok(GeneratedField::EfConstruction),
2121                            "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2122                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2123                        }
2124                    }
2125                }
2126                deserializer.deserialize_identifier(GeneratedVisitor)
2127            }
2128        }
2129        struct GeneratedVisitor;
2130        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2131            type Value = HnswFlatIndexConfig;
2132
2133            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2134                formatter.write_str("struct catalog.HnswFlatIndexConfig")
2135            }
2136
2137            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexConfig, V::Error>
2138                where
2139                    V: serde::de::MapAccess<'de>,
2140            {
2141                let mut m__ = None;
2142                let mut ef_construction__ = None;
2143                let mut max_level__ = None;
2144                while let Some(k) = map_.next_key()? {
2145                    match k {
2146                        GeneratedField::M => {
2147                            if m__.is_some() {
2148                                return Err(serde::de::Error::duplicate_field("m"));
2149                            }
2150                            m__ = 
2151                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2152                            ;
2153                        }
2154                        GeneratedField::EfConstruction => {
2155                            if ef_construction__.is_some() {
2156                                return Err(serde::de::Error::duplicate_field("efConstruction"));
2157                            }
2158                            ef_construction__ = 
2159                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2160                            ;
2161                        }
2162                        GeneratedField::MaxLevel => {
2163                            if max_level__.is_some() {
2164                                return Err(serde::de::Error::duplicate_field("maxLevel"));
2165                            }
2166                            max_level__ = 
2167                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2168                            ;
2169                        }
2170                    }
2171                }
2172                Ok(HnswFlatIndexConfig {
2173                    m: m__.unwrap_or_default(),
2174                    ef_construction: ef_construction__.unwrap_or_default(),
2175                    max_level: max_level__.unwrap_or_default(),
2176                })
2177            }
2178        }
2179        deserializer.deserialize_struct("catalog.HnswFlatIndexConfig", FIELDS, GeneratedVisitor)
2180    }
2181}
2182impl serde::Serialize for Index {
2183    #[allow(deprecated)]
2184    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2185    where
2186        S: serde::Serializer,
2187    {
2188        use serde::ser::SerializeStruct;
2189        let mut len = 0;
2190        if self.id != 0 {
2191            len += 1;
2192        }
2193        if self.schema_id != 0 {
2194            len += 1;
2195        }
2196        if self.database_id != 0 {
2197            len += 1;
2198        }
2199        if !self.name.is_empty() {
2200            len += 1;
2201        }
2202        if self.owner != 0 {
2203            len += 1;
2204        }
2205        if self.index_table_id != 0 {
2206            len += 1;
2207        }
2208        if self.primary_table_id != 0 {
2209            len += 1;
2210        }
2211        if !self.index_item.is_empty() {
2212            len += 1;
2213        }
2214        if !self.index_column_properties.is_empty() {
2215            len += 1;
2216        }
2217        if self.initialized_at_epoch.is_some() {
2218            len += 1;
2219        }
2220        if self.created_at_epoch.is_some() {
2221            len += 1;
2222        }
2223        if self.stream_job_status != 0 {
2224            len += 1;
2225        }
2226        if self.index_columns_len != 0 {
2227            len += 1;
2228        }
2229        if self.initialized_at_cluster_version.is_some() {
2230            len += 1;
2231        }
2232        if self.created_at_cluster_version.is_some() {
2233            len += 1;
2234        }
2235        if self.create_type != 0 {
2236            len += 1;
2237        }
2238        let mut struct_ser = serializer.serialize_struct("catalog.Index", len)?;
2239        if self.id != 0 {
2240            struct_ser.serialize_field("id", &self.id)?;
2241        }
2242        if self.schema_id != 0 {
2243            struct_ser.serialize_field("schemaId", &self.schema_id)?;
2244        }
2245        if self.database_id != 0 {
2246            struct_ser.serialize_field("databaseId", &self.database_id)?;
2247        }
2248        if !self.name.is_empty() {
2249            struct_ser.serialize_field("name", &self.name)?;
2250        }
2251        if self.owner != 0 {
2252            struct_ser.serialize_field("owner", &self.owner)?;
2253        }
2254        if self.index_table_id != 0 {
2255            struct_ser.serialize_field("indexTableId", &self.index_table_id)?;
2256        }
2257        if self.primary_table_id != 0 {
2258            struct_ser.serialize_field("primaryTableId", &self.primary_table_id)?;
2259        }
2260        if !self.index_item.is_empty() {
2261            struct_ser.serialize_field("indexItem", &self.index_item)?;
2262        }
2263        if !self.index_column_properties.is_empty() {
2264            struct_ser.serialize_field("indexColumnProperties", &self.index_column_properties)?;
2265        }
2266        if let Some(v) = self.initialized_at_epoch.as_ref() {
2267            #[allow(clippy::needless_borrow)]
2268            #[allow(clippy::needless_borrows_for_generic_args)]
2269            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
2270        }
2271        if let Some(v) = self.created_at_epoch.as_ref() {
2272            #[allow(clippy::needless_borrow)]
2273            #[allow(clippy::needless_borrows_for_generic_args)]
2274            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
2275        }
2276        if self.stream_job_status != 0 {
2277            let v = StreamJobStatus::try_from(self.stream_job_status)
2278                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
2279            struct_ser.serialize_field("streamJobStatus", &v)?;
2280        }
2281        if self.index_columns_len != 0 {
2282            struct_ser.serialize_field("indexColumnsLen", &self.index_columns_len)?;
2283        }
2284        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
2285            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
2286        }
2287        if let Some(v) = self.created_at_cluster_version.as_ref() {
2288            struct_ser.serialize_field("createdAtClusterVersion", v)?;
2289        }
2290        if self.create_type != 0 {
2291            let v = CreateType::try_from(self.create_type)
2292                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
2293            struct_ser.serialize_field("createType", &v)?;
2294        }
2295        struct_ser.end()
2296    }
2297}
2298impl<'de> serde::Deserialize<'de> for Index {
2299    #[allow(deprecated)]
2300    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2301    where
2302        D: serde::Deserializer<'de>,
2303    {
2304        const FIELDS: &[&str] = &[
2305            "id",
2306            "schema_id",
2307            "schemaId",
2308            "database_id",
2309            "databaseId",
2310            "name",
2311            "owner",
2312            "index_table_id",
2313            "indexTableId",
2314            "primary_table_id",
2315            "primaryTableId",
2316            "index_item",
2317            "indexItem",
2318            "index_column_properties",
2319            "indexColumnProperties",
2320            "initialized_at_epoch",
2321            "initializedAtEpoch",
2322            "created_at_epoch",
2323            "createdAtEpoch",
2324            "stream_job_status",
2325            "streamJobStatus",
2326            "index_columns_len",
2327            "indexColumnsLen",
2328            "initialized_at_cluster_version",
2329            "initializedAtClusterVersion",
2330            "created_at_cluster_version",
2331            "createdAtClusterVersion",
2332            "create_type",
2333            "createType",
2334        ];
2335
2336        #[allow(clippy::enum_variant_names)]
2337        enum GeneratedField {
2338            Id,
2339            SchemaId,
2340            DatabaseId,
2341            Name,
2342            Owner,
2343            IndexTableId,
2344            PrimaryTableId,
2345            IndexItem,
2346            IndexColumnProperties,
2347            InitializedAtEpoch,
2348            CreatedAtEpoch,
2349            StreamJobStatus,
2350            IndexColumnsLen,
2351            InitializedAtClusterVersion,
2352            CreatedAtClusterVersion,
2353            CreateType,
2354        }
2355        impl<'de> serde::Deserialize<'de> for GeneratedField {
2356            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2357            where
2358                D: serde::Deserializer<'de>,
2359            {
2360                struct GeneratedVisitor;
2361
2362                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2363                    type Value = GeneratedField;
2364
2365                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2366                        write!(formatter, "expected one of: {:?}", &FIELDS)
2367                    }
2368
2369                    #[allow(unused_variables)]
2370                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2371                    where
2372                        E: serde::de::Error,
2373                    {
2374                        match value {
2375                            "id" => Ok(GeneratedField::Id),
2376                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2377                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2378                            "name" => Ok(GeneratedField::Name),
2379                            "owner" => Ok(GeneratedField::Owner),
2380                            "indexTableId" | "index_table_id" => Ok(GeneratedField::IndexTableId),
2381                            "primaryTableId" | "primary_table_id" => Ok(GeneratedField::PrimaryTableId),
2382                            "indexItem" | "index_item" => Ok(GeneratedField::IndexItem),
2383                            "indexColumnProperties" | "index_column_properties" => Ok(GeneratedField::IndexColumnProperties),
2384                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
2385                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
2386                            "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
2387                            "indexColumnsLen" | "index_columns_len" => Ok(GeneratedField::IndexColumnsLen),
2388                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
2389                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
2390                            "createType" | "create_type" => Ok(GeneratedField::CreateType),
2391                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2392                        }
2393                    }
2394                }
2395                deserializer.deserialize_identifier(GeneratedVisitor)
2396            }
2397        }
2398        struct GeneratedVisitor;
2399        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2400            type Value = Index;
2401
2402            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2403                formatter.write_str("struct catalog.Index")
2404            }
2405
2406            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Index, V::Error>
2407                where
2408                    V: serde::de::MapAccess<'de>,
2409            {
2410                let mut id__ = None;
2411                let mut schema_id__ = None;
2412                let mut database_id__ = None;
2413                let mut name__ = None;
2414                let mut owner__ = None;
2415                let mut index_table_id__ = None;
2416                let mut primary_table_id__ = None;
2417                let mut index_item__ = None;
2418                let mut index_column_properties__ = None;
2419                let mut initialized_at_epoch__ = None;
2420                let mut created_at_epoch__ = None;
2421                let mut stream_job_status__ = None;
2422                let mut index_columns_len__ = None;
2423                let mut initialized_at_cluster_version__ = None;
2424                let mut created_at_cluster_version__ = None;
2425                let mut create_type__ = None;
2426                while let Some(k) = map_.next_key()? {
2427                    match k {
2428                        GeneratedField::Id => {
2429                            if id__.is_some() {
2430                                return Err(serde::de::Error::duplicate_field("id"));
2431                            }
2432                            id__ = 
2433                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2434                            ;
2435                        }
2436                        GeneratedField::SchemaId => {
2437                            if schema_id__.is_some() {
2438                                return Err(serde::de::Error::duplicate_field("schemaId"));
2439                            }
2440                            schema_id__ = 
2441                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2442                            ;
2443                        }
2444                        GeneratedField::DatabaseId => {
2445                            if database_id__.is_some() {
2446                                return Err(serde::de::Error::duplicate_field("databaseId"));
2447                            }
2448                            database_id__ = 
2449                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2450                            ;
2451                        }
2452                        GeneratedField::Name => {
2453                            if name__.is_some() {
2454                                return Err(serde::de::Error::duplicate_field("name"));
2455                            }
2456                            name__ = Some(map_.next_value()?);
2457                        }
2458                        GeneratedField::Owner => {
2459                            if owner__.is_some() {
2460                                return Err(serde::de::Error::duplicate_field("owner"));
2461                            }
2462                            owner__ = 
2463                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2464                            ;
2465                        }
2466                        GeneratedField::IndexTableId => {
2467                            if index_table_id__.is_some() {
2468                                return Err(serde::de::Error::duplicate_field("indexTableId"));
2469                            }
2470                            index_table_id__ = 
2471                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2472                            ;
2473                        }
2474                        GeneratedField::PrimaryTableId => {
2475                            if primary_table_id__.is_some() {
2476                                return Err(serde::de::Error::duplicate_field("primaryTableId"));
2477                            }
2478                            primary_table_id__ = 
2479                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2480                            ;
2481                        }
2482                        GeneratedField::IndexItem => {
2483                            if index_item__.is_some() {
2484                                return Err(serde::de::Error::duplicate_field("indexItem"));
2485                            }
2486                            index_item__ = Some(map_.next_value()?);
2487                        }
2488                        GeneratedField::IndexColumnProperties => {
2489                            if index_column_properties__.is_some() {
2490                                return Err(serde::de::Error::duplicate_field("indexColumnProperties"));
2491                            }
2492                            index_column_properties__ = Some(map_.next_value()?);
2493                        }
2494                        GeneratedField::InitializedAtEpoch => {
2495                            if initialized_at_epoch__.is_some() {
2496                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
2497                            }
2498                            initialized_at_epoch__ = 
2499                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2500                            ;
2501                        }
2502                        GeneratedField::CreatedAtEpoch => {
2503                            if created_at_epoch__.is_some() {
2504                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
2505                            }
2506                            created_at_epoch__ = 
2507                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2508                            ;
2509                        }
2510                        GeneratedField::StreamJobStatus => {
2511                            if stream_job_status__.is_some() {
2512                                return Err(serde::de::Error::duplicate_field("streamJobStatus"));
2513                            }
2514                            stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
2515                        }
2516                        GeneratedField::IndexColumnsLen => {
2517                            if index_columns_len__.is_some() {
2518                                return Err(serde::de::Error::duplicate_field("indexColumnsLen"));
2519                            }
2520                            index_columns_len__ = 
2521                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2522                            ;
2523                        }
2524                        GeneratedField::InitializedAtClusterVersion => {
2525                            if initialized_at_cluster_version__.is_some() {
2526                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
2527                            }
2528                            initialized_at_cluster_version__ = map_.next_value()?;
2529                        }
2530                        GeneratedField::CreatedAtClusterVersion => {
2531                            if created_at_cluster_version__.is_some() {
2532                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
2533                            }
2534                            created_at_cluster_version__ = map_.next_value()?;
2535                        }
2536                        GeneratedField::CreateType => {
2537                            if create_type__.is_some() {
2538                                return Err(serde::de::Error::duplicate_field("createType"));
2539                            }
2540                            create_type__ = Some(map_.next_value::<CreateType>()? as i32);
2541                        }
2542                    }
2543                }
2544                Ok(Index {
2545                    id: id__.unwrap_or_default(),
2546                    schema_id: schema_id__.unwrap_or_default(),
2547                    database_id: database_id__.unwrap_or_default(),
2548                    name: name__.unwrap_or_default(),
2549                    owner: owner__.unwrap_or_default(),
2550                    index_table_id: index_table_id__.unwrap_or_default(),
2551                    primary_table_id: primary_table_id__.unwrap_or_default(),
2552                    index_item: index_item__.unwrap_or_default(),
2553                    index_column_properties: index_column_properties__.unwrap_or_default(),
2554                    initialized_at_epoch: initialized_at_epoch__,
2555                    created_at_epoch: created_at_epoch__,
2556                    stream_job_status: stream_job_status__.unwrap_or_default(),
2557                    index_columns_len: index_columns_len__.unwrap_or_default(),
2558                    initialized_at_cluster_version: initialized_at_cluster_version__,
2559                    created_at_cluster_version: created_at_cluster_version__,
2560                    create_type: create_type__.unwrap_or_default(),
2561                })
2562            }
2563        }
2564        deserializer.deserialize_struct("catalog.Index", FIELDS, GeneratedVisitor)
2565    }
2566}
2567impl serde::Serialize for IndexColumnProperties {
2568    #[allow(deprecated)]
2569    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2570    where
2571        S: serde::Serializer,
2572    {
2573        use serde::ser::SerializeStruct;
2574        let mut len = 0;
2575        if self.is_desc {
2576            len += 1;
2577        }
2578        if self.nulls_first {
2579            len += 1;
2580        }
2581        let mut struct_ser = serializer.serialize_struct("catalog.IndexColumnProperties", len)?;
2582        if self.is_desc {
2583            struct_ser.serialize_field("isDesc", &self.is_desc)?;
2584        }
2585        if self.nulls_first {
2586            struct_ser.serialize_field("nullsFirst", &self.nulls_first)?;
2587        }
2588        struct_ser.end()
2589    }
2590}
2591impl<'de> serde::Deserialize<'de> for IndexColumnProperties {
2592    #[allow(deprecated)]
2593    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2594    where
2595        D: serde::Deserializer<'de>,
2596    {
2597        const FIELDS: &[&str] = &[
2598            "is_desc",
2599            "isDesc",
2600            "nulls_first",
2601            "nullsFirst",
2602        ];
2603
2604        #[allow(clippy::enum_variant_names)]
2605        enum GeneratedField {
2606            IsDesc,
2607            NullsFirst,
2608        }
2609        impl<'de> serde::Deserialize<'de> for GeneratedField {
2610            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2611            where
2612                D: serde::Deserializer<'de>,
2613            {
2614                struct GeneratedVisitor;
2615
2616                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2617                    type Value = GeneratedField;
2618
2619                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2620                        write!(formatter, "expected one of: {:?}", &FIELDS)
2621                    }
2622
2623                    #[allow(unused_variables)]
2624                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2625                    where
2626                        E: serde::de::Error,
2627                    {
2628                        match value {
2629                            "isDesc" | "is_desc" => Ok(GeneratedField::IsDesc),
2630                            "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
2631                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2632                        }
2633                    }
2634                }
2635                deserializer.deserialize_identifier(GeneratedVisitor)
2636            }
2637        }
2638        struct GeneratedVisitor;
2639        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2640            type Value = IndexColumnProperties;
2641
2642            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2643                formatter.write_str("struct catalog.IndexColumnProperties")
2644            }
2645
2646            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IndexColumnProperties, V::Error>
2647                where
2648                    V: serde::de::MapAccess<'de>,
2649            {
2650                let mut is_desc__ = None;
2651                let mut nulls_first__ = None;
2652                while let Some(k) = map_.next_key()? {
2653                    match k {
2654                        GeneratedField::IsDesc => {
2655                            if is_desc__.is_some() {
2656                                return Err(serde::de::Error::duplicate_field("isDesc"));
2657                            }
2658                            is_desc__ = Some(map_.next_value()?);
2659                        }
2660                        GeneratedField::NullsFirst => {
2661                            if nulls_first__.is_some() {
2662                                return Err(serde::de::Error::duplicate_field("nullsFirst"));
2663                            }
2664                            nulls_first__ = Some(map_.next_value()?);
2665                        }
2666                    }
2667                }
2668                Ok(IndexColumnProperties {
2669                    is_desc: is_desc__.unwrap_or_default(),
2670                    nulls_first: nulls_first__.unwrap_or_default(),
2671                })
2672            }
2673        }
2674        deserializer.deserialize_struct("catalog.IndexColumnProperties", FIELDS, GeneratedVisitor)
2675    }
2676}
2677impl serde::Serialize for OptionsWithSecret {
2678    #[allow(deprecated)]
2679    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2680    where
2681        S: serde::Serializer,
2682    {
2683        use serde::ser::SerializeStruct;
2684        let mut len = 0;
2685        if !self.options.is_empty() {
2686            len += 1;
2687        }
2688        if !self.secret_refs.is_empty() {
2689            len += 1;
2690        }
2691        let mut struct_ser = serializer.serialize_struct("catalog.OptionsWithSecret", len)?;
2692        if !self.options.is_empty() {
2693            struct_ser.serialize_field("options", &self.options)?;
2694        }
2695        if !self.secret_refs.is_empty() {
2696            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
2697        }
2698        struct_ser.end()
2699    }
2700}
2701impl<'de> serde::Deserialize<'de> for OptionsWithSecret {
2702    #[allow(deprecated)]
2703    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2704    where
2705        D: serde::Deserializer<'de>,
2706    {
2707        const FIELDS: &[&str] = &[
2708            "options",
2709            "secret_refs",
2710            "secretRefs",
2711        ];
2712
2713        #[allow(clippy::enum_variant_names)]
2714        enum GeneratedField {
2715            Options,
2716            SecretRefs,
2717        }
2718        impl<'de> serde::Deserialize<'de> for GeneratedField {
2719            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2720            where
2721                D: serde::Deserializer<'de>,
2722            {
2723                struct GeneratedVisitor;
2724
2725                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2726                    type Value = GeneratedField;
2727
2728                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2729                        write!(formatter, "expected one of: {:?}", &FIELDS)
2730                    }
2731
2732                    #[allow(unused_variables)]
2733                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2734                    where
2735                        E: serde::de::Error,
2736                    {
2737                        match value {
2738                            "options" => Ok(GeneratedField::Options),
2739                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
2740                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2741                        }
2742                    }
2743                }
2744                deserializer.deserialize_identifier(GeneratedVisitor)
2745            }
2746        }
2747        struct GeneratedVisitor;
2748        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2749            type Value = OptionsWithSecret;
2750
2751            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2752                formatter.write_str("struct catalog.OptionsWithSecret")
2753            }
2754
2755            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionsWithSecret, V::Error>
2756                where
2757                    V: serde::de::MapAccess<'de>,
2758            {
2759                let mut options__ = None;
2760                let mut secret_refs__ = None;
2761                while let Some(k) = map_.next_key()? {
2762                    match k {
2763                        GeneratedField::Options => {
2764                            if options__.is_some() {
2765                                return Err(serde::de::Error::duplicate_field("options"));
2766                            }
2767                            options__ = Some(
2768                                map_.next_value::<std::collections::HashMap<_, _>>()?
2769                            );
2770                        }
2771                        GeneratedField::SecretRefs => {
2772                            if secret_refs__.is_some() {
2773                                return Err(serde::de::Error::duplicate_field("secretRefs"));
2774                            }
2775                            secret_refs__ = Some(
2776                                map_.next_value::<std::collections::HashMap<_, _>>()?
2777                            );
2778                        }
2779                    }
2780                }
2781                Ok(OptionsWithSecret {
2782                    options: options__.unwrap_or_default(),
2783                    secret_refs: secret_refs__.unwrap_or_default(),
2784                })
2785            }
2786        }
2787        deserializer.deserialize_struct("catalog.OptionsWithSecret", FIELDS, GeneratedVisitor)
2788    }
2789}
2790impl serde::Serialize for RefreshState {
2791    #[allow(deprecated)]
2792    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2793    where
2794        S: serde::Serializer,
2795    {
2796        let variant = match self {
2797            Self::Unspecified => "REFRESH_STATE_UNSPECIFIED",
2798            Self::Idle => "REFRESH_STATE_IDLE",
2799            Self::Refreshing => "REFRESH_STATE_REFRESHING",
2800            Self::Finishing => "REFRESH_STATE_FINISHING",
2801        };
2802        serializer.serialize_str(variant)
2803    }
2804}
2805impl<'de> serde::Deserialize<'de> for RefreshState {
2806    #[allow(deprecated)]
2807    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2808    where
2809        D: serde::Deserializer<'de>,
2810    {
2811        const FIELDS: &[&str] = &[
2812            "REFRESH_STATE_UNSPECIFIED",
2813            "REFRESH_STATE_IDLE",
2814            "REFRESH_STATE_REFRESHING",
2815            "REFRESH_STATE_FINISHING",
2816        ];
2817
2818        struct GeneratedVisitor;
2819
2820        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2821            type Value = RefreshState;
2822
2823            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2824                write!(formatter, "expected one of: {:?}", &FIELDS)
2825            }
2826
2827            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2828            where
2829                E: serde::de::Error,
2830            {
2831                i32::try_from(v)
2832                    .ok()
2833                    .and_then(|x| x.try_into().ok())
2834                    .ok_or_else(|| {
2835                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2836                    })
2837            }
2838
2839            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2840            where
2841                E: serde::de::Error,
2842            {
2843                i32::try_from(v)
2844                    .ok()
2845                    .and_then(|x| x.try_into().ok())
2846                    .ok_or_else(|| {
2847                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2848                    })
2849            }
2850
2851            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2852            where
2853                E: serde::de::Error,
2854            {
2855                match value {
2856                    "REFRESH_STATE_UNSPECIFIED" => Ok(RefreshState::Unspecified),
2857                    "REFRESH_STATE_IDLE" => Ok(RefreshState::Idle),
2858                    "REFRESH_STATE_REFRESHING" => Ok(RefreshState::Refreshing),
2859                    "REFRESH_STATE_FINISHING" => Ok(RefreshState::Finishing),
2860                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2861                }
2862            }
2863        }
2864        deserializer.deserialize_any(GeneratedVisitor)
2865    }
2866}
2867impl serde::Serialize for Schema {
2868    #[allow(deprecated)]
2869    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2870    where
2871        S: serde::Serializer,
2872    {
2873        use serde::ser::SerializeStruct;
2874        let mut len = 0;
2875        if self.id != 0 {
2876            len += 1;
2877        }
2878        if self.database_id != 0 {
2879            len += 1;
2880        }
2881        if !self.name.is_empty() {
2882            len += 1;
2883        }
2884        if self.owner != 0 {
2885            len += 1;
2886        }
2887        let mut struct_ser = serializer.serialize_struct("catalog.Schema", len)?;
2888        if self.id != 0 {
2889            struct_ser.serialize_field("id", &self.id)?;
2890        }
2891        if self.database_id != 0 {
2892            struct_ser.serialize_field("databaseId", &self.database_id)?;
2893        }
2894        if !self.name.is_empty() {
2895            struct_ser.serialize_field("name", &self.name)?;
2896        }
2897        if self.owner != 0 {
2898            struct_ser.serialize_field("owner", &self.owner)?;
2899        }
2900        struct_ser.end()
2901    }
2902}
2903impl<'de> serde::Deserialize<'de> for Schema {
2904    #[allow(deprecated)]
2905    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2906    where
2907        D: serde::Deserializer<'de>,
2908    {
2909        const FIELDS: &[&str] = &[
2910            "id",
2911            "database_id",
2912            "databaseId",
2913            "name",
2914            "owner",
2915        ];
2916
2917        #[allow(clippy::enum_variant_names)]
2918        enum GeneratedField {
2919            Id,
2920            DatabaseId,
2921            Name,
2922            Owner,
2923        }
2924        impl<'de> serde::Deserialize<'de> for GeneratedField {
2925            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2926            where
2927                D: serde::Deserializer<'de>,
2928            {
2929                struct GeneratedVisitor;
2930
2931                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2932                    type Value = GeneratedField;
2933
2934                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2935                        write!(formatter, "expected one of: {:?}", &FIELDS)
2936                    }
2937
2938                    #[allow(unused_variables)]
2939                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2940                    where
2941                        E: serde::de::Error,
2942                    {
2943                        match value {
2944                            "id" => Ok(GeneratedField::Id),
2945                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2946                            "name" => Ok(GeneratedField::Name),
2947                            "owner" => Ok(GeneratedField::Owner),
2948                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2949                        }
2950                    }
2951                }
2952                deserializer.deserialize_identifier(GeneratedVisitor)
2953            }
2954        }
2955        struct GeneratedVisitor;
2956        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2957            type Value = Schema;
2958
2959            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2960                formatter.write_str("struct catalog.Schema")
2961            }
2962
2963            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Schema, V::Error>
2964                where
2965                    V: serde::de::MapAccess<'de>,
2966            {
2967                let mut id__ = None;
2968                let mut database_id__ = None;
2969                let mut name__ = None;
2970                let mut owner__ = None;
2971                while let Some(k) = map_.next_key()? {
2972                    match k {
2973                        GeneratedField::Id => {
2974                            if id__.is_some() {
2975                                return Err(serde::de::Error::duplicate_field("id"));
2976                            }
2977                            id__ = 
2978                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2979                            ;
2980                        }
2981                        GeneratedField::DatabaseId => {
2982                            if database_id__.is_some() {
2983                                return Err(serde::de::Error::duplicate_field("databaseId"));
2984                            }
2985                            database_id__ = 
2986                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2987                            ;
2988                        }
2989                        GeneratedField::Name => {
2990                            if name__.is_some() {
2991                                return Err(serde::de::Error::duplicate_field("name"));
2992                            }
2993                            name__ = Some(map_.next_value()?);
2994                        }
2995                        GeneratedField::Owner => {
2996                            if owner__.is_some() {
2997                                return Err(serde::de::Error::duplicate_field("owner"));
2998                            }
2999                            owner__ = 
3000                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3001                            ;
3002                        }
3003                    }
3004                }
3005                Ok(Schema {
3006                    id: id__.unwrap_or_default(),
3007                    database_id: database_id__.unwrap_or_default(),
3008                    name: name__.unwrap_or_default(),
3009                    owner: owner__.unwrap_or_default(),
3010                })
3011            }
3012        }
3013        deserializer.deserialize_struct("catalog.Schema", FIELDS, GeneratedVisitor)
3014    }
3015}
3016impl serde::Serialize for SchemaRegistryNameStrategy {
3017    #[allow(deprecated)]
3018    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3019    where
3020        S: serde::Serializer,
3021    {
3022        let variant = match self {
3023            Self::Unspecified => "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
3024            Self::RecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
3025            Self::TopicRecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
3026        };
3027        serializer.serialize_str(variant)
3028    }
3029}
3030impl<'de> serde::Deserialize<'de> for SchemaRegistryNameStrategy {
3031    #[allow(deprecated)]
3032    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3033    where
3034        D: serde::Deserializer<'de>,
3035    {
3036        const FIELDS: &[&str] = &[
3037            "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
3038            "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
3039            "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
3040        ];
3041
3042        struct GeneratedVisitor;
3043
3044        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3045            type Value = SchemaRegistryNameStrategy;
3046
3047            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3048                write!(formatter, "expected one of: {:?}", &FIELDS)
3049            }
3050
3051            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3052            where
3053                E: serde::de::Error,
3054            {
3055                i32::try_from(v)
3056                    .ok()
3057                    .and_then(|x| x.try_into().ok())
3058                    .ok_or_else(|| {
3059                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3060                    })
3061            }
3062
3063            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3064            where
3065                E: serde::de::Error,
3066            {
3067                i32::try_from(v)
3068                    .ok()
3069                    .and_then(|x| x.try_into().ok())
3070                    .ok_or_else(|| {
3071                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3072                    })
3073            }
3074
3075            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3076            where
3077                E: serde::de::Error,
3078            {
3079                match value {
3080                    "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED" => Ok(SchemaRegistryNameStrategy::Unspecified),
3081                    "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::RecordNameStrategy),
3082                    "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::TopicRecordNameStrategy),
3083                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3084                }
3085            }
3086        }
3087        deserializer.deserialize_any(GeneratedVisitor)
3088    }
3089}
3090impl serde::Serialize for Secret {
3091    #[allow(deprecated)]
3092    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3093    where
3094        S: serde::Serializer,
3095    {
3096        use serde::ser::SerializeStruct;
3097        let mut len = 0;
3098        if self.id != 0 {
3099            len += 1;
3100        }
3101        if !self.name.is_empty() {
3102            len += 1;
3103        }
3104        if self.database_id != 0 {
3105            len += 1;
3106        }
3107        if !self.value.is_empty() {
3108            len += 1;
3109        }
3110        if self.owner != 0 {
3111            len += 1;
3112        }
3113        if self.schema_id != 0 {
3114            len += 1;
3115        }
3116        let mut struct_ser = serializer.serialize_struct("catalog.Secret", len)?;
3117        if self.id != 0 {
3118            struct_ser.serialize_field("id", &self.id)?;
3119        }
3120        if !self.name.is_empty() {
3121            struct_ser.serialize_field("name", &self.name)?;
3122        }
3123        if self.database_id != 0 {
3124            struct_ser.serialize_field("databaseId", &self.database_id)?;
3125        }
3126        if !self.value.is_empty() {
3127            #[allow(clippy::needless_borrow)]
3128            #[allow(clippy::needless_borrows_for_generic_args)]
3129            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
3130        }
3131        if self.owner != 0 {
3132            struct_ser.serialize_field("owner", &self.owner)?;
3133        }
3134        if self.schema_id != 0 {
3135            struct_ser.serialize_field("schemaId", &self.schema_id)?;
3136        }
3137        struct_ser.end()
3138    }
3139}
3140impl<'de> serde::Deserialize<'de> for Secret {
3141    #[allow(deprecated)]
3142    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3143    where
3144        D: serde::Deserializer<'de>,
3145    {
3146        const FIELDS: &[&str] = &[
3147            "id",
3148            "name",
3149            "database_id",
3150            "databaseId",
3151            "value",
3152            "owner",
3153            "schema_id",
3154            "schemaId",
3155        ];
3156
3157        #[allow(clippy::enum_variant_names)]
3158        enum GeneratedField {
3159            Id,
3160            Name,
3161            DatabaseId,
3162            Value,
3163            Owner,
3164            SchemaId,
3165        }
3166        impl<'de> serde::Deserialize<'de> for GeneratedField {
3167            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3168            where
3169                D: serde::Deserializer<'de>,
3170            {
3171                struct GeneratedVisitor;
3172
3173                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3174                    type Value = GeneratedField;
3175
3176                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3177                        write!(formatter, "expected one of: {:?}", &FIELDS)
3178                    }
3179
3180                    #[allow(unused_variables)]
3181                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3182                    where
3183                        E: serde::de::Error,
3184                    {
3185                        match value {
3186                            "id" => Ok(GeneratedField::Id),
3187                            "name" => Ok(GeneratedField::Name),
3188                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3189                            "value" => Ok(GeneratedField::Value),
3190                            "owner" => Ok(GeneratedField::Owner),
3191                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3192                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3193                        }
3194                    }
3195                }
3196                deserializer.deserialize_identifier(GeneratedVisitor)
3197            }
3198        }
3199        struct GeneratedVisitor;
3200        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3201            type Value = Secret;
3202
3203            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3204                formatter.write_str("struct catalog.Secret")
3205            }
3206
3207            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Secret, V::Error>
3208                where
3209                    V: serde::de::MapAccess<'de>,
3210            {
3211                let mut id__ = None;
3212                let mut name__ = None;
3213                let mut database_id__ = None;
3214                let mut value__ = None;
3215                let mut owner__ = None;
3216                let mut schema_id__ = None;
3217                while let Some(k) = map_.next_key()? {
3218                    match k {
3219                        GeneratedField::Id => {
3220                            if id__.is_some() {
3221                                return Err(serde::de::Error::duplicate_field("id"));
3222                            }
3223                            id__ = 
3224                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3225                            ;
3226                        }
3227                        GeneratedField::Name => {
3228                            if name__.is_some() {
3229                                return Err(serde::de::Error::duplicate_field("name"));
3230                            }
3231                            name__ = Some(map_.next_value()?);
3232                        }
3233                        GeneratedField::DatabaseId => {
3234                            if database_id__.is_some() {
3235                                return Err(serde::de::Error::duplicate_field("databaseId"));
3236                            }
3237                            database_id__ = 
3238                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3239                            ;
3240                        }
3241                        GeneratedField::Value => {
3242                            if value__.is_some() {
3243                                return Err(serde::de::Error::duplicate_field("value"));
3244                            }
3245                            value__ = 
3246                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
3247                            ;
3248                        }
3249                        GeneratedField::Owner => {
3250                            if owner__.is_some() {
3251                                return Err(serde::de::Error::duplicate_field("owner"));
3252                            }
3253                            owner__ = 
3254                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3255                            ;
3256                        }
3257                        GeneratedField::SchemaId => {
3258                            if schema_id__.is_some() {
3259                                return Err(serde::de::Error::duplicate_field("schemaId"));
3260                            }
3261                            schema_id__ = 
3262                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3263                            ;
3264                        }
3265                    }
3266                }
3267                Ok(Secret {
3268                    id: id__.unwrap_or_default(),
3269                    name: name__.unwrap_or_default(),
3270                    database_id: database_id__.unwrap_or_default(),
3271                    value: value__.unwrap_or_default(),
3272                    owner: owner__.unwrap_or_default(),
3273                    schema_id: schema_id__.unwrap_or_default(),
3274                })
3275            }
3276        }
3277        deserializer.deserialize_struct("catalog.Secret", FIELDS, GeneratedVisitor)
3278    }
3279}
3280impl serde::Serialize for Sink {
3281    #[allow(deprecated)]
3282    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3283    where
3284        S: serde::Serializer,
3285    {
3286        use serde::ser::SerializeStruct;
3287        let mut len = 0;
3288        if self.id != 0 {
3289            len += 1;
3290        }
3291        if self.schema_id != 0 {
3292            len += 1;
3293        }
3294        if self.database_id != 0 {
3295            len += 1;
3296        }
3297        if !self.name.is_empty() {
3298            len += 1;
3299        }
3300        if !self.columns.is_empty() {
3301            len += 1;
3302        }
3303        if !self.plan_pk.is_empty() {
3304            len += 1;
3305        }
3306        if !self.distribution_key.is_empty() {
3307            len += 1;
3308        }
3309        if !self.downstream_pk.is_empty() {
3310            len += 1;
3311        }
3312        if self.sink_type != 0 {
3313            len += 1;
3314        }
3315        if self.owner != 0 {
3316            len += 1;
3317        }
3318        if !self.properties.is_empty() {
3319            len += 1;
3320        }
3321        if !self.definition.is_empty() {
3322            len += 1;
3323        }
3324        if self.connection_id.is_some() {
3325            len += 1;
3326        }
3327        if self.initialized_at_epoch.is_some() {
3328            len += 1;
3329        }
3330        if self.created_at_epoch.is_some() {
3331            len += 1;
3332        }
3333        if !self.db_name.is_empty() {
3334            len += 1;
3335        }
3336        if !self.sink_from_name.is_empty() {
3337            len += 1;
3338        }
3339        if self.stream_job_status != 0 {
3340            len += 1;
3341        }
3342        if self.format_desc.is_some() {
3343            len += 1;
3344        }
3345        if self.target_table.is_some() {
3346            len += 1;
3347        }
3348        if self.initialized_at_cluster_version.is_some() {
3349            len += 1;
3350        }
3351        if self.created_at_cluster_version.is_some() {
3352            len += 1;
3353        }
3354        if self.create_type != 0 {
3355            len += 1;
3356        }
3357        if !self.secret_refs.is_empty() {
3358            len += 1;
3359        }
3360        if !self.original_target_columns.is_empty() {
3361            len += 1;
3362        }
3363        if self.auto_refresh_schema_from_table.is_some() {
3364            len += 1;
3365        }
3366        let mut struct_ser = serializer.serialize_struct("catalog.Sink", len)?;
3367        if self.id != 0 {
3368            struct_ser.serialize_field("id", &self.id)?;
3369        }
3370        if self.schema_id != 0 {
3371            struct_ser.serialize_field("schemaId", &self.schema_id)?;
3372        }
3373        if self.database_id != 0 {
3374            struct_ser.serialize_field("databaseId", &self.database_id)?;
3375        }
3376        if !self.name.is_empty() {
3377            struct_ser.serialize_field("name", &self.name)?;
3378        }
3379        if !self.columns.is_empty() {
3380            struct_ser.serialize_field("columns", &self.columns)?;
3381        }
3382        if !self.plan_pk.is_empty() {
3383            struct_ser.serialize_field("planPk", &self.plan_pk)?;
3384        }
3385        if !self.distribution_key.is_empty() {
3386            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
3387        }
3388        if !self.downstream_pk.is_empty() {
3389            struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
3390        }
3391        if self.sink_type != 0 {
3392            let v = SinkType::try_from(self.sink_type)
3393                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
3394            struct_ser.serialize_field("sinkType", &v)?;
3395        }
3396        if self.owner != 0 {
3397            struct_ser.serialize_field("owner", &self.owner)?;
3398        }
3399        if !self.properties.is_empty() {
3400            struct_ser.serialize_field("properties", &self.properties)?;
3401        }
3402        if !self.definition.is_empty() {
3403            struct_ser.serialize_field("definition", &self.definition)?;
3404        }
3405        if let Some(v) = self.connection_id.as_ref() {
3406            struct_ser.serialize_field("connectionId", v)?;
3407        }
3408        if let Some(v) = self.initialized_at_epoch.as_ref() {
3409            #[allow(clippy::needless_borrow)]
3410            #[allow(clippy::needless_borrows_for_generic_args)]
3411            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3412        }
3413        if let Some(v) = self.created_at_epoch.as_ref() {
3414            #[allow(clippy::needless_borrow)]
3415            #[allow(clippy::needless_borrows_for_generic_args)]
3416            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3417        }
3418        if !self.db_name.is_empty() {
3419            struct_ser.serialize_field("dbName", &self.db_name)?;
3420        }
3421        if !self.sink_from_name.is_empty() {
3422            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
3423        }
3424        if self.stream_job_status != 0 {
3425            let v = StreamJobStatus::try_from(self.stream_job_status)
3426                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
3427            struct_ser.serialize_field("streamJobStatus", &v)?;
3428        }
3429        if let Some(v) = self.format_desc.as_ref() {
3430            struct_ser.serialize_field("formatDesc", v)?;
3431        }
3432        if let Some(v) = self.target_table.as_ref() {
3433            struct_ser.serialize_field("targetTable", v)?;
3434        }
3435        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3436            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3437        }
3438        if let Some(v) = self.created_at_cluster_version.as_ref() {
3439            struct_ser.serialize_field("createdAtClusterVersion", v)?;
3440        }
3441        if self.create_type != 0 {
3442            let v = CreateType::try_from(self.create_type)
3443                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
3444            struct_ser.serialize_field("createType", &v)?;
3445        }
3446        if !self.secret_refs.is_empty() {
3447            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3448        }
3449        if !self.original_target_columns.is_empty() {
3450            struct_ser.serialize_field("originalTargetColumns", &self.original_target_columns)?;
3451        }
3452        if let Some(v) = self.auto_refresh_schema_from_table.as_ref() {
3453            struct_ser.serialize_field("autoRefreshSchemaFromTable", v)?;
3454        }
3455        struct_ser.end()
3456    }
3457}
3458impl<'de> serde::Deserialize<'de> for Sink {
3459    #[allow(deprecated)]
3460    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3461    where
3462        D: serde::Deserializer<'de>,
3463    {
3464        const FIELDS: &[&str] = &[
3465            "id",
3466            "schema_id",
3467            "schemaId",
3468            "database_id",
3469            "databaseId",
3470            "name",
3471            "columns",
3472            "plan_pk",
3473            "planPk",
3474            "distribution_key",
3475            "distributionKey",
3476            "downstream_pk",
3477            "downstreamPk",
3478            "sink_type",
3479            "sinkType",
3480            "owner",
3481            "properties",
3482            "definition",
3483            "connection_id",
3484            "connectionId",
3485            "initialized_at_epoch",
3486            "initializedAtEpoch",
3487            "created_at_epoch",
3488            "createdAtEpoch",
3489            "db_name",
3490            "dbName",
3491            "sink_from_name",
3492            "sinkFromName",
3493            "stream_job_status",
3494            "streamJobStatus",
3495            "format_desc",
3496            "formatDesc",
3497            "target_table",
3498            "targetTable",
3499            "initialized_at_cluster_version",
3500            "initializedAtClusterVersion",
3501            "created_at_cluster_version",
3502            "createdAtClusterVersion",
3503            "create_type",
3504            "createType",
3505            "secret_refs",
3506            "secretRefs",
3507            "original_target_columns",
3508            "originalTargetColumns",
3509            "auto_refresh_schema_from_table",
3510            "autoRefreshSchemaFromTable",
3511        ];
3512
3513        #[allow(clippy::enum_variant_names)]
3514        enum GeneratedField {
3515            Id,
3516            SchemaId,
3517            DatabaseId,
3518            Name,
3519            Columns,
3520            PlanPk,
3521            DistributionKey,
3522            DownstreamPk,
3523            SinkType,
3524            Owner,
3525            Properties,
3526            Definition,
3527            ConnectionId,
3528            InitializedAtEpoch,
3529            CreatedAtEpoch,
3530            DbName,
3531            SinkFromName,
3532            StreamJobStatus,
3533            FormatDesc,
3534            TargetTable,
3535            InitializedAtClusterVersion,
3536            CreatedAtClusterVersion,
3537            CreateType,
3538            SecretRefs,
3539            OriginalTargetColumns,
3540            AutoRefreshSchemaFromTable,
3541        }
3542        impl<'de> serde::Deserialize<'de> for GeneratedField {
3543            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3544            where
3545                D: serde::Deserializer<'de>,
3546            {
3547                struct GeneratedVisitor;
3548
3549                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3550                    type Value = GeneratedField;
3551
3552                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3553                        write!(formatter, "expected one of: {:?}", &FIELDS)
3554                    }
3555
3556                    #[allow(unused_variables)]
3557                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3558                    where
3559                        E: serde::de::Error,
3560                    {
3561                        match value {
3562                            "id" => Ok(GeneratedField::Id),
3563                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3564                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3565                            "name" => Ok(GeneratedField::Name),
3566                            "columns" => Ok(GeneratedField::Columns),
3567                            "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
3568                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
3569                            "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
3570                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
3571                            "owner" => Ok(GeneratedField::Owner),
3572                            "properties" => Ok(GeneratedField::Properties),
3573                            "definition" => Ok(GeneratedField::Definition),
3574                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3575                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
3576                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
3577                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
3578                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
3579                            "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
3580                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
3581                            "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
3582                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
3583                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
3584                            "createType" | "create_type" => Ok(GeneratedField::CreateType),
3585                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3586                            "originalTargetColumns" | "original_target_columns" => Ok(GeneratedField::OriginalTargetColumns),
3587                            "autoRefreshSchemaFromTable" | "auto_refresh_schema_from_table" => Ok(GeneratedField::AutoRefreshSchemaFromTable),
3588                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3589                        }
3590                    }
3591                }
3592                deserializer.deserialize_identifier(GeneratedVisitor)
3593            }
3594        }
3595        struct GeneratedVisitor;
3596        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3597            type Value = Sink;
3598
3599            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3600                formatter.write_str("struct catalog.Sink")
3601            }
3602
3603            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Sink, V::Error>
3604                where
3605                    V: serde::de::MapAccess<'de>,
3606            {
3607                let mut id__ = None;
3608                let mut schema_id__ = None;
3609                let mut database_id__ = None;
3610                let mut name__ = None;
3611                let mut columns__ = None;
3612                let mut plan_pk__ = None;
3613                let mut distribution_key__ = None;
3614                let mut downstream_pk__ = None;
3615                let mut sink_type__ = None;
3616                let mut owner__ = None;
3617                let mut properties__ = None;
3618                let mut definition__ = None;
3619                let mut connection_id__ = None;
3620                let mut initialized_at_epoch__ = None;
3621                let mut created_at_epoch__ = None;
3622                let mut db_name__ = None;
3623                let mut sink_from_name__ = None;
3624                let mut stream_job_status__ = None;
3625                let mut format_desc__ = None;
3626                let mut target_table__ = None;
3627                let mut initialized_at_cluster_version__ = None;
3628                let mut created_at_cluster_version__ = None;
3629                let mut create_type__ = None;
3630                let mut secret_refs__ = None;
3631                let mut original_target_columns__ = None;
3632                let mut auto_refresh_schema_from_table__ = None;
3633                while let Some(k) = map_.next_key()? {
3634                    match k {
3635                        GeneratedField::Id => {
3636                            if id__.is_some() {
3637                                return Err(serde::de::Error::duplicate_field("id"));
3638                            }
3639                            id__ = 
3640                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3641                            ;
3642                        }
3643                        GeneratedField::SchemaId => {
3644                            if schema_id__.is_some() {
3645                                return Err(serde::de::Error::duplicate_field("schemaId"));
3646                            }
3647                            schema_id__ = 
3648                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3649                            ;
3650                        }
3651                        GeneratedField::DatabaseId => {
3652                            if database_id__.is_some() {
3653                                return Err(serde::de::Error::duplicate_field("databaseId"));
3654                            }
3655                            database_id__ = 
3656                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3657                            ;
3658                        }
3659                        GeneratedField::Name => {
3660                            if name__.is_some() {
3661                                return Err(serde::de::Error::duplicate_field("name"));
3662                            }
3663                            name__ = Some(map_.next_value()?);
3664                        }
3665                        GeneratedField::Columns => {
3666                            if columns__.is_some() {
3667                                return Err(serde::de::Error::duplicate_field("columns"));
3668                            }
3669                            columns__ = Some(map_.next_value()?);
3670                        }
3671                        GeneratedField::PlanPk => {
3672                            if plan_pk__.is_some() {
3673                                return Err(serde::de::Error::duplicate_field("planPk"));
3674                            }
3675                            plan_pk__ = Some(map_.next_value()?);
3676                        }
3677                        GeneratedField::DistributionKey => {
3678                            if distribution_key__.is_some() {
3679                                return Err(serde::de::Error::duplicate_field("distributionKey"));
3680                            }
3681                            distribution_key__ = 
3682                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3683                                    .into_iter().map(|x| x.0).collect())
3684                            ;
3685                        }
3686                        GeneratedField::DownstreamPk => {
3687                            if downstream_pk__.is_some() {
3688                                return Err(serde::de::Error::duplicate_field("downstreamPk"));
3689                            }
3690                            downstream_pk__ = 
3691                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3692                                    .into_iter().map(|x| x.0).collect())
3693                            ;
3694                        }
3695                        GeneratedField::SinkType => {
3696                            if sink_type__.is_some() {
3697                                return Err(serde::de::Error::duplicate_field("sinkType"));
3698                            }
3699                            sink_type__ = Some(map_.next_value::<SinkType>()? as i32);
3700                        }
3701                        GeneratedField::Owner => {
3702                            if owner__.is_some() {
3703                                return Err(serde::de::Error::duplicate_field("owner"));
3704                            }
3705                            owner__ = 
3706                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3707                            ;
3708                        }
3709                        GeneratedField::Properties => {
3710                            if properties__.is_some() {
3711                                return Err(serde::de::Error::duplicate_field("properties"));
3712                            }
3713                            properties__ = Some(
3714                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3715                            );
3716                        }
3717                        GeneratedField::Definition => {
3718                            if definition__.is_some() {
3719                                return Err(serde::de::Error::duplicate_field("definition"));
3720                            }
3721                            definition__ = Some(map_.next_value()?);
3722                        }
3723                        GeneratedField::ConnectionId => {
3724                            if connection_id__.is_some() {
3725                                return Err(serde::de::Error::duplicate_field("connectionId"));
3726                            }
3727                            connection_id__ = 
3728                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3729                            ;
3730                        }
3731                        GeneratedField::InitializedAtEpoch => {
3732                            if initialized_at_epoch__.is_some() {
3733                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
3734                            }
3735                            initialized_at_epoch__ = 
3736                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3737                            ;
3738                        }
3739                        GeneratedField::CreatedAtEpoch => {
3740                            if created_at_epoch__.is_some() {
3741                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
3742                            }
3743                            created_at_epoch__ = 
3744                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3745                            ;
3746                        }
3747                        GeneratedField::DbName => {
3748                            if db_name__.is_some() {
3749                                return Err(serde::de::Error::duplicate_field("dbName"));
3750                            }
3751                            db_name__ = Some(map_.next_value()?);
3752                        }
3753                        GeneratedField::SinkFromName => {
3754                            if sink_from_name__.is_some() {
3755                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
3756                            }
3757                            sink_from_name__ = Some(map_.next_value()?);
3758                        }
3759                        GeneratedField::StreamJobStatus => {
3760                            if stream_job_status__.is_some() {
3761                                return Err(serde::de::Error::duplicate_field("streamJobStatus"));
3762                            }
3763                            stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
3764                        }
3765                        GeneratedField::FormatDesc => {
3766                            if format_desc__.is_some() {
3767                                return Err(serde::de::Error::duplicate_field("formatDesc"));
3768                            }
3769                            format_desc__ = map_.next_value()?;
3770                        }
3771                        GeneratedField::TargetTable => {
3772                            if target_table__.is_some() {
3773                                return Err(serde::de::Error::duplicate_field("targetTable"));
3774                            }
3775                            target_table__ = 
3776                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3777                            ;
3778                        }
3779                        GeneratedField::InitializedAtClusterVersion => {
3780                            if initialized_at_cluster_version__.is_some() {
3781                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
3782                            }
3783                            initialized_at_cluster_version__ = map_.next_value()?;
3784                        }
3785                        GeneratedField::CreatedAtClusterVersion => {
3786                            if created_at_cluster_version__.is_some() {
3787                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
3788                            }
3789                            created_at_cluster_version__ = map_.next_value()?;
3790                        }
3791                        GeneratedField::CreateType => {
3792                            if create_type__.is_some() {
3793                                return Err(serde::de::Error::duplicate_field("createType"));
3794                            }
3795                            create_type__ = Some(map_.next_value::<CreateType>()? as i32);
3796                        }
3797                        GeneratedField::SecretRefs => {
3798                            if secret_refs__.is_some() {
3799                                return Err(serde::de::Error::duplicate_field("secretRefs"));
3800                            }
3801                            secret_refs__ = Some(
3802                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3803                            );
3804                        }
3805                        GeneratedField::OriginalTargetColumns => {
3806                            if original_target_columns__.is_some() {
3807                                return Err(serde::de::Error::duplicate_field("originalTargetColumns"));
3808                            }
3809                            original_target_columns__ = Some(map_.next_value()?);
3810                        }
3811                        GeneratedField::AutoRefreshSchemaFromTable => {
3812                            if auto_refresh_schema_from_table__.is_some() {
3813                                return Err(serde::de::Error::duplicate_field("autoRefreshSchemaFromTable"));
3814                            }
3815                            auto_refresh_schema_from_table__ = 
3816                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3817                            ;
3818                        }
3819                    }
3820                }
3821                Ok(Sink {
3822                    id: id__.unwrap_or_default(),
3823                    schema_id: schema_id__.unwrap_or_default(),
3824                    database_id: database_id__.unwrap_or_default(),
3825                    name: name__.unwrap_or_default(),
3826                    columns: columns__.unwrap_or_default(),
3827                    plan_pk: plan_pk__.unwrap_or_default(),
3828                    distribution_key: distribution_key__.unwrap_or_default(),
3829                    downstream_pk: downstream_pk__.unwrap_or_default(),
3830                    sink_type: sink_type__.unwrap_or_default(),
3831                    owner: owner__.unwrap_or_default(),
3832                    properties: properties__.unwrap_or_default(),
3833                    definition: definition__.unwrap_or_default(),
3834                    connection_id: connection_id__,
3835                    initialized_at_epoch: initialized_at_epoch__,
3836                    created_at_epoch: created_at_epoch__,
3837                    db_name: db_name__.unwrap_or_default(),
3838                    sink_from_name: sink_from_name__.unwrap_or_default(),
3839                    stream_job_status: stream_job_status__.unwrap_or_default(),
3840                    format_desc: format_desc__,
3841                    target_table: target_table__,
3842                    initialized_at_cluster_version: initialized_at_cluster_version__,
3843                    created_at_cluster_version: created_at_cluster_version__,
3844                    create_type: create_type__.unwrap_or_default(),
3845                    secret_refs: secret_refs__.unwrap_or_default(),
3846                    original_target_columns: original_target_columns__.unwrap_or_default(),
3847                    auto_refresh_schema_from_table: auto_refresh_schema_from_table__,
3848                })
3849            }
3850        }
3851        deserializer.deserialize_struct("catalog.Sink", FIELDS, GeneratedVisitor)
3852    }
3853}
3854impl serde::Serialize for SinkFormatDesc {
3855    #[allow(deprecated)]
3856    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3857    where
3858        S: serde::Serializer,
3859    {
3860        use serde::ser::SerializeStruct;
3861        let mut len = 0;
3862        if self.format != 0 {
3863            len += 1;
3864        }
3865        if self.encode != 0 {
3866            len += 1;
3867        }
3868        if !self.options.is_empty() {
3869            len += 1;
3870        }
3871        if self.key_encode.is_some() {
3872            len += 1;
3873        }
3874        if !self.secret_refs.is_empty() {
3875            len += 1;
3876        }
3877        if self.connection_id.is_some() {
3878            len += 1;
3879        }
3880        let mut struct_ser = serializer.serialize_struct("catalog.SinkFormatDesc", len)?;
3881        if self.format != 0 {
3882            let v = super::plan_common::FormatType::try_from(self.format)
3883                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
3884            struct_ser.serialize_field("format", &v)?;
3885        }
3886        if self.encode != 0 {
3887            let v = super::plan_common::EncodeType::try_from(self.encode)
3888                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encode)))?;
3889            struct_ser.serialize_field("encode", &v)?;
3890        }
3891        if !self.options.is_empty() {
3892            struct_ser.serialize_field("options", &self.options)?;
3893        }
3894        if let Some(v) = self.key_encode.as_ref() {
3895            let v = super::plan_common::EncodeType::try_from(*v)
3896                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
3897            struct_ser.serialize_field("keyEncode", &v)?;
3898        }
3899        if !self.secret_refs.is_empty() {
3900            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3901        }
3902        if let Some(v) = self.connection_id.as_ref() {
3903            struct_ser.serialize_field("connectionId", v)?;
3904        }
3905        struct_ser.end()
3906    }
3907}
3908impl<'de> serde::Deserialize<'de> for SinkFormatDesc {
3909    #[allow(deprecated)]
3910    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3911    where
3912        D: serde::Deserializer<'de>,
3913    {
3914        const FIELDS: &[&str] = &[
3915            "format",
3916            "encode",
3917            "options",
3918            "key_encode",
3919            "keyEncode",
3920            "secret_refs",
3921            "secretRefs",
3922            "connection_id",
3923            "connectionId",
3924        ];
3925
3926        #[allow(clippy::enum_variant_names)]
3927        enum GeneratedField {
3928            Format,
3929            Encode,
3930            Options,
3931            KeyEncode,
3932            SecretRefs,
3933            ConnectionId,
3934        }
3935        impl<'de> serde::Deserialize<'de> for GeneratedField {
3936            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3937            where
3938                D: serde::Deserializer<'de>,
3939            {
3940                struct GeneratedVisitor;
3941
3942                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3943                    type Value = GeneratedField;
3944
3945                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3946                        write!(formatter, "expected one of: {:?}", &FIELDS)
3947                    }
3948
3949                    #[allow(unused_variables)]
3950                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3951                    where
3952                        E: serde::de::Error,
3953                    {
3954                        match value {
3955                            "format" => Ok(GeneratedField::Format),
3956                            "encode" => Ok(GeneratedField::Encode),
3957                            "options" => Ok(GeneratedField::Options),
3958                            "keyEncode" | "key_encode" => Ok(GeneratedField::KeyEncode),
3959                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3960                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3961                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3962                        }
3963                    }
3964                }
3965                deserializer.deserialize_identifier(GeneratedVisitor)
3966            }
3967        }
3968        struct GeneratedVisitor;
3969        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3970            type Value = SinkFormatDesc;
3971
3972            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3973                formatter.write_str("struct catalog.SinkFormatDesc")
3974            }
3975
3976            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkFormatDesc, V::Error>
3977                where
3978                    V: serde::de::MapAccess<'de>,
3979            {
3980                let mut format__ = None;
3981                let mut encode__ = None;
3982                let mut options__ = None;
3983                let mut key_encode__ = None;
3984                let mut secret_refs__ = None;
3985                let mut connection_id__ = None;
3986                while let Some(k) = map_.next_key()? {
3987                    match k {
3988                        GeneratedField::Format => {
3989                            if format__.is_some() {
3990                                return Err(serde::de::Error::duplicate_field("format"));
3991                            }
3992                            format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
3993                        }
3994                        GeneratedField::Encode => {
3995                            if encode__.is_some() {
3996                                return Err(serde::de::Error::duplicate_field("encode"));
3997                            }
3998                            encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
3999                        }
4000                        GeneratedField::Options => {
4001                            if options__.is_some() {
4002                                return Err(serde::de::Error::duplicate_field("options"));
4003                            }
4004                            options__ = Some(
4005                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4006                            );
4007                        }
4008                        GeneratedField::KeyEncode => {
4009                            if key_encode__.is_some() {
4010                                return Err(serde::de::Error::duplicate_field("keyEncode"));
4011                            }
4012                            key_encode__ = map_.next_value::<::std::option::Option<super::plan_common::EncodeType>>()?.map(|x| x as i32);
4013                        }
4014                        GeneratedField::SecretRefs => {
4015                            if secret_refs__.is_some() {
4016                                return Err(serde::de::Error::duplicate_field("secretRefs"));
4017                            }
4018                            secret_refs__ = Some(
4019                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4020                            );
4021                        }
4022                        GeneratedField::ConnectionId => {
4023                            if connection_id__.is_some() {
4024                                return Err(serde::de::Error::duplicate_field("connectionId"));
4025                            }
4026                            connection_id__ = 
4027                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4028                            ;
4029                        }
4030                    }
4031                }
4032                Ok(SinkFormatDesc {
4033                    format: format__.unwrap_or_default(),
4034                    encode: encode__.unwrap_or_default(),
4035                    options: options__.unwrap_or_default(),
4036                    key_encode: key_encode__,
4037                    secret_refs: secret_refs__.unwrap_or_default(),
4038                    connection_id: connection_id__,
4039                })
4040            }
4041        }
4042        deserializer.deserialize_struct("catalog.SinkFormatDesc", FIELDS, GeneratedVisitor)
4043    }
4044}
4045impl serde::Serialize for SinkType {
4046    #[allow(deprecated)]
4047    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4048    where
4049        S: serde::Serializer,
4050    {
4051        let variant = match self {
4052            Self::Unspecified => "SINK_TYPE_UNSPECIFIED",
4053            Self::AppendOnly => "SINK_TYPE_APPEND_ONLY",
4054            Self::ForceAppendOnly => "SINK_TYPE_FORCE_APPEND_ONLY",
4055            Self::Upsert => "SINK_TYPE_UPSERT",
4056        };
4057        serializer.serialize_str(variant)
4058    }
4059}
4060impl<'de> serde::Deserialize<'de> for SinkType {
4061    #[allow(deprecated)]
4062    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4063    where
4064        D: serde::Deserializer<'de>,
4065    {
4066        const FIELDS: &[&str] = &[
4067            "SINK_TYPE_UNSPECIFIED",
4068            "SINK_TYPE_APPEND_ONLY",
4069            "SINK_TYPE_FORCE_APPEND_ONLY",
4070            "SINK_TYPE_UPSERT",
4071        ];
4072
4073        struct GeneratedVisitor;
4074
4075        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4076            type Value = SinkType;
4077
4078            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4079                write!(formatter, "expected one of: {:?}", &FIELDS)
4080            }
4081
4082            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4083            where
4084                E: serde::de::Error,
4085            {
4086                i32::try_from(v)
4087                    .ok()
4088                    .and_then(|x| x.try_into().ok())
4089                    .ok_or_else(|| {
4090                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4091                    })
4092            }
4093
4094            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4095            where
4096                E: serde::de::Error,
4097            {
4098                i32::try_from(v)
4099                    .ok()
4100                    .and_then(|x| x.try_into().ok())
4101                    .ok_or_else(|| {
4102                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4103                    })
4104            }
4105
4106            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4107            where
4108                E: serde::de::Error,
4109            {
4110                match value {
4111                    "SINK_TYPE_UNSPECIFIED" => Ok(SinkType::Unspecified),
4112                    "SINK_TYPE_APPEND_ONLY" => Ok(SinkType::AppendOnly),
4113                    "SINK_TYPE_FORCE_APPEND_ONLY" => Ok(SinkType::ForceAppendOnly),
4114                    "SINK_TYPE_UPSERT" => Ok(SinkType::Upsert),
4115                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4116                }
4117            }
4118        }
4119        deserializer.deserialize_any(GeneratedVisitor)
4120    }
4121}
4122impl serde::Serialize for Source {
4123    #[allow(deprecated)]
4124    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4125    where
4126        S: serde::Serializer,
4127    {
4128        use serde::ser::SerializeStruct;
4129        let mut len = 0;
4130        if self.id != 0 {
4131            len += 1;
4132        }
4133        if self.schema_id != 0 {
4134            len += 1;
4135        }
4136        if self.database_id != 0 {
4137            len += 1;
4138        }
4139        if !self.name.is_empty() {
4140            len += 1;
4141        }
4142        if self.row_id_index.is_some() {
4143            len += 1;
4144        }
4145        if !self.columns.is_empty() {
4146            len += 1;
4147        }
4148        if !self.pk_column_ids.is_empty() {
4149            len += 1;
4150        }
4151        if !self.with_properties.is_empty() {
4152            len += 1;
4153        }
4154        if self.owner != 0 {
4155            len += 1;
4156        }
4157        if self.info.is_some() {
4158            len += 1;
4159        }
4160        if !self.watermark_descs.is_empty() {
4161            len += 1;
4162        }
4163        if !self.definition.is_empty() {
4164            len += 1;
4165        }
4166        if self.connection_id.is_some() {
4167            len += 1;
4168        }
4169        if self.initialized_at_epoch.is_some() {
4170            len += 1;
4171        }
4172        if self.created_at_epoch.is_some() {
4173            len += 1;
4174        }
4175        if self.initialized_at_cluster_version.is_some() {
4176            len += 1;
4177        }
4178        if self.created_at_cluster_version.is_some() {
4179            len += 1;
4180        }
4181        if !self.secret_refs.is_empty() {
4182            len += 1;
4183        }
4184        if self.version != 0 {
4185            len += 1;
4186        }
4187        if self.rate_limit.is_some() {
4188            len += 1;
4189        }
4190        if self.optional_associated_table_id.is_some() {
4191            len += 1;
4192        }
4193        let mut struct_ser = serializer.serialize_struct("catalog.Source", len)?;
4194        if self.id != 0 {
4195            struct_ser.serialize_field("id", &self.id)?;
4196        }
4197        if self.schema_id != 0 {
4198            struct_ser.serialize_field("schemaId", &self.schema_id)?;
4199        }
4200        if self.database_id != 0 {
4201            struct_ser.serialize_field("databaseId", &self.database_id)?;
4202        }
4203        if !self.name.is_empty() {
4204            struct_ser.serialize_field("name", &self.name)?;
4205        }
4206        if let Some(v) = self.row_id_index.as_ref() {
4207            struct_ser.serialize_field("rowIdIndex", v)?;
4208        }
4209        if !self.columns.is_empty() {
4210            struct_ser.serialize_field("columns", &self.columns)?;
4211        }
4212        if !self.pk_column_ids.is_empty() {
4213            struct_ser.serialize_field("pkColumnIds", &self.pk_column_ids)?;
4214        }
4215        if !self.with_properties.is_empty() {
4216            struct_ser.serialize_field("withProperties", &self.with_properties)?;
4217        }
4218        if self.owner != 0 {
4219            struct_ser.serialize_field("owner", &self.owner)?;
4220        }
4221        if let Some(v) = self.info.as_ref() {
4222            struct_ser.serialize_field("info", v)?;
4223        }
4224        if !self.watermark_descs.is_empty() {
4225            struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
4226        }
4227        if !self.definition.is_empty() {
4228            struct_ser.serialize_field("definition", &self.definition)?;
4229        }
4230        if let Some(v) = self.connection_id.as_ref() {
4231            struct_ser.serialize_field("connectionId", v)?;
4232        }
4233        if let Some(v) = self.initialized_at_epoch.as_ref() {
4234            #[allow(clippy::needless_borrow)]
4235            #[allow(clippy::needless_borrows_for_generic_args)]
4236            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
4237        }
4238        if let Some(v) = self.created_at_epoch.as_ref() {
4239            #[allow(clippy::needless_borrow)]
4240            #[allow(clippy::needless_borrows_for_generic_args)]
4241            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
4242        }
4243        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
4244            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
4245        }
4246        if let Some(v) = self.created_at_cluster_version.as_ref() {
4247            struct_ser.serialize_field("createdAtClusterVersion", v)?;
4248        }
4249        if !self.secret_refs.is_empty() {
4250            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
4251        }
4252        if self.version != 0 {
4253            #[allow(clippy::needless_borrow)]
4254            #[allow(clippy::needless_borrows_for_generic_args)]
4255            struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
4256        }
4257        if let Some(v) = self.rate_limit.as_ref() {
4258            struct_ser.serialize_field("rateLimit", v)?;
4259        }
4260        if let Some(v) = self.optional_associated_table_id.as_ref() {
4261            match v {
4262                source::OptionalAssociatedTableId::AssociatedTableId(v) => {
4263                    struct_ser.serialize_field("associatedTableId", v)?;
4264                }
4265            }
4266        }
4267        struct_ser.end()
4268    }
4269}
4270impl<'de> serde::Deserialize<'de> for Source {
4271    #[allow(deprecated)]
4272    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4273    where
4274        D: serde::Deserializer<'de>,
4275    {
4276        const FIELDS: &[&str] = &[
4277            "id",
4278            "schema_id",
4279            "schemaId",
4280            "database_id",
4281            "databaseId",
4282            "name",
4283            "row_id_index",
4284            "rowIdIndex",
4285            "columns",
4286            "pk_column_ids",
4287            "pkColumnIds",
4288            "with_properties",
4289            "withProperties",
4290            "owner",
4291            "info",
4292            "watermark_descs",
4293            "watermarkDescs",
4294            "definition",
4295            "connection_id",
4296            "connectionId",
4297            "initialized_at_epoch",
4298            "initializedAtEpoch",
4299            "created_at_epoch",
4300            "createdAtEpoch",
4301            "initialized_at_cluster_version",
4302            "initializedAtClusterVersion",
4303            "created_at_cluster_version",
4304            "createdAtClusterVersion",
4305            "secret_refs",
4306            "secretRefs",
4307            "version",
4308            "rate_limit",
4309            "rateLimit",
4310            "associated_table_id",
4311            "associatedTableId",
4312        ];
4313
4314        #[allow(clippy::enum_variant_names)]
4315        enum GeneratedField {
4316            Id,
4317            SchemaId,
4318            DatabaseId,
4319            Name,
4320            RowIdIndex,
4321            Columns,
4322            PkColumnIds,
4323            WithProperties,
4324            Owner,
4325            Info,
4326            WatermarkDescs,
4327            Definition,
4328            ConnectionId,
4329            InitializedAtEpoch,
4330            CreatedAtEpoch,
4331            InitializedAtClusterVersion,
4332            CreatedAtClusterVersion,
4333            SecretRefs,
4334            Version,
4335            RateLimit,
4336            AssociatedTableId,
4337        }
4338        impl<'de> serde::Deserialize<'de> for GeneratedField {
4339            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4340            where
4341                D: serde::Deserializer<'de>,
4342            {
4343                struct GeneratedVisitor;
4344
4345                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4346                    type Value = GeneratedField;
4347
4348                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4349                        write!(formatter, "expected one of: {:?}", &FIELDS)
4350                    }
4351
4352                    #[allow(unused_variables)]
4353                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4354                    where
4355                        E: serde::de::Error,
4356                    {
4357                        match value {
4358                            "id" => Ok(GeneratedField::Id),
4359                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4360                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4361                            "name" => Ok(GeneratedField::Name),
4362                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
4363                            "columns" => Ok(GeneratedField::Columns),
4364                            "pkColumnIds" | "pk_column_ids" => Ok(GeneratedField::PkColumnIds),
4365                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
4366                            "owner" => Ok(GeneratedField::Owner),
4367                            "info" => Ok(GeneratedField::Info),
4368                            "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
4369                            "definition" => Ok(GeneratedField::Definition),
4370                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4371                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4372                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4373                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4374                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4375                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
4376                            "version" => Ok(GeneratedField::Version),
4377                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4378                            "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
4379                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4380                        }
4381                    }
4382                }
4383                deserializer.deserialize_identifier(GeneratedVisitor)
4384            }
4385        }
4386        struct GeneratedVisitor;
4387        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4388            type Value = Source;
4389
4390            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4391                formatter.write_str("struct catalog.Source")
4392            }
4393
4394            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Source, V::Error>
4395                where
4396                    V: serde::de::MapAccess<'de>,
4397            {
4398                let mut id__ = None;
4399                let mut schema_id__ = None;
4400                let mut database_id__ = None;
4401                let mut name__ = None;
4402                let mut row_id_index__ = None;
4403                let mut columns__ = None;
4404                let mut pk_column_ids__ = None;
4405                let mut with_properties__ = None;
4406                let mut owner__ = None;
4407                let mut info__ = None;
4408                let mut watermark_descs__ = None;
4409                let mut definition__ = None;
4410                let mut connection_id__ = None;
4411                let mut initialized_at_epoch__ = None;
4412                let mut created_at_epoch__ = None;
4413                let mut initialized_at_cluster_version__ = None;
4414                let mut created_at_cluster_version__ = None;
4415                let mut secret_refs__ = None;
4416                let mut version__ = None;
4417                let mut rate_limit__ = None;
4418                let mut optional_associated_table_id__ = None;
4419                while let Some(k) = map_.next_key()? {
4420                    match k {
4421                        GeneratedField::Id => {
4422                            if id__.is_some() {
4423                                return Err(serde::de::Error::duplicate_field("id"));
4424                            }
4425                            id__ = 
4426                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4427                            ;
4428                        }
4429                        GeneratedField::SchemaId => {
4430                            if schema_id__.is_some() {
4431                                return Err(serde::de::Error::duplicate_field("schemaId"));
4432                            }
4433                            schema_id__ = 
4434                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4435                            ;
4436                        }
4437                        GeneratedField::DatabaseId => {
4438                            if database_id__.is_some() {
4439                                return Err(serde::de::Error::duplicate_field("databaseId"));
4440                            }
4441                            database_id__ = 
4442                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4443                            ;
4444                        }
4445                        GeneratedField::Name => {
4446                            if name__.is_some() {
4447                                return Err(serde::de::Error::duplicate_field("name"));
4448                            }
4449                            name__ = Some(map_.next_value()?);
4450                        }
4451                        GeneratedField::RowIdIndex => {
4452                            if row_id_index__.is_some() {
4453                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
4454                            }
4455                            row_id_index__ = 
4456                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4457                            ;
4458                        }
4459                        GeneratedField::Columns => {
4460                            if columns__.is_some() {
4461                                return Err(serde::de::Error::duplicate_field("columns"));
4462                            }
4463                            columns__ = Some(map_.next_value()?);
4464                        }
4465                        GeneratedField::PkColumnIds => {
4466                            if pk_column_ids__.is_some() {
4467                                return Err(serde::de::Error::duplicate_field("pkColumnIds"));
4468                            }
4469                            pk_column_ids__ = 
4470                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4471                                    .into_iter().map(|x| x.0).collect())
4472                            ;
4473                        }
4474                        GeneratedField::WithProperties => {
4475                            if with_properties__.is_some() {
4476                                return Err(serde::de::Error::duplicate_field("withProperties"));
4477                            }
4478                            with_properties__ = Some(
4479                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4480                            );
4481                        }
4482                        GeneratedField::Owner => {
4483                            if owner__.is_some() {
4484                                return Err(serde::de::Error::duplicate_field("owner"));
4485                            }
4486                            owner__ = 
4487                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4488                            ;
4489                        }
4490                        GeneratedField::Info => {
4491                            if info__.is_some() {
4492                                return Err(serde::de::Error::duplicate_field("info"));
4493                            }
4494                            info__ = map_.next_value()?;
4495                        }
4496                        GeneratedField::WatermarkDescs => {
4497                            if watermark_descs__.is_some() {
4498                                return Err(serde::de::Error::duplicate_field("watermarkDescs"));
4499                            }
4500                            watermark_descs__ = Some(map_.next_value()?);
4501                        }
4502                        GeneratedField::Definition => {
4503                            if definition__.is_some() {
4504                                return Err(serde::de::Error::duplicate_field("definition"));
4505                            }
4506                            definition__ = Some(map_.next_value()?);
4507                        }
4508                        GeneratedField::ConnectionId => {
4509                            if connection_id__.is_some() {
4510                                return Err(serde::de::Error::duplicate_field("connectionId"));
4511                            }
4512                            connection_id__ = 
4513                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4514                            ;
4515                        }
4516                        GeneratedField::InitializedAtEpoch => {
4517                            if initialized_at_epoch__.is_some() {
4518                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4519                            }
4520                            initialized_at_epoch__ = 
4521                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4522                            ;
4523                        }
4524                        GeneratedField::CreatedAtEpoch => {
4525                            if created_at_epoch__.is_some() {
4526                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4527                            }
4528                            created_at_epoch__ = 
4529                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4530                            ;
4531                        }
4532                        GeneratedField::InitializedAtClusterVersion => {
4533                            if initialized_at_cluster_version__.is_some() {
4534                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4535                            }
4536                            initialized_at_cluster_version__ = map_.next_value()?;
4537                        }
4538                        GeneratedField::CreatedAtClusterVersion => {
4539                            if created_at_cluster_version__.is_some() {
4540                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4541                            }
4542                            created_at_cluster_version__ = map_.next_value()?;
4543                        }
4544                        GeneratedField::SecretRefs => {
4545                            if secret_refs__.is_some() {
4546                                return Err(serde::de::Error::duplicate_field("secretRefs"));
4547                            }
4548                            secret_refs__ = Some(
4549                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4550                            );
4551                        }
4552                        GeneratedField::Version => {
4553                            if version__.is_some() {
4554                                return Err(serde::de::Error::duplicate_field("version"));
4555                            }
4556                            version__ = 
4557                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4558                            ;
4559                        }
4560                        GeneratedField::RateLimit => {
4561                            if rate_limit__.is_some() {
4562                                return Err(serde::de::Error::duplicate_field("rateLimit"));
4563                            }
4564                            rate_limit__ = 
4565                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4566                            ;
4567                        }
4568                        GeneratedField::AssociatedTableId => {
4569                            if optional_associated_table_id__.is_some() {
4570                                return Err(serde::de::Error::duplicate_field("associatedTableId"));
4571                            }
4572                            optional_associated_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| source::OptionalAssociatedTableId::AssociatedTableId(x.0));
4573                        }
4574                    }
4575                }
4576                Ok(Source {
4577                    id: id__.unwrap_or_default(),
4578                    schema_id: schema_id__.unwrap_or_default(),
4579                    database_id: database_id__.unwrap_or_default(),
4580                    name: name__.unwrap_or_default(),
4581                    row_id_index: row_id_index__,
4582                    columns: columns__.unwrap_or_default(),
4583                    pk_column_ids: pk_column_ids__.unwrap_or_default(),
4584                    with_properties: with_properties__.unwrap_or_default(),
4585                    owner: owner__.unwrap_or_default(),
4586                    info: info__,
4587                    watermark_descs: watermark_descs__.unwrap_or_default(),
4588                    definition: definition__.unwrap_or_default(),
4589                    connection_id: connection_id__,
4590                    initialized_at_epoch: initialized_at_epoch__,
4591                    created_at_epoch: created_at_epoch__,
4592                    initialized_at_cluster_version: initialized_at_cluster_version__,
4593                    created_at_cluster_version: created_at_cluster_version__,
4594                    secret_refs: secret_refs__.unwrap_or_default(),
4595                    version: version__.unwrap_or_default(),
4596                    rate_limit: rate_limit__,
4597                    optional_associated_table_id: optional_associated_table_id__,
4598                })
4599            }
4600        }
4601        deserializer.deserialize_struct("catalog.Source", FIELDS, GeneratedVisitor)
4602    }
4603}
4604impl serde::Serialize for StreamJobStatus {
4605    #[allow(deprecated)]
4606    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4607    where
4608        S: serde::Serializer,
4609    {
4610        let variant = match self {
4611            Self::Unspecified => "STREAM_JOB_STATUS_UNSPECIFIED",
4612            Self::Creating => "STREAM_JOB_STATUS_CREATING",
4613            Self::Created => "STREAM_JOB_STATUS_CREATED",
4614        };
4615        serializer.serialize_str(variant)
4616    }
4617}
4618impl<'de> serde::Deserialize<'de> for StreamJobStatus {
4619    #[allow(deprecated)]
4620    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4621    where
4622        D: serde::Deserializer<'de>,
4623    {
4624        const FIELDS: &[&str] = &[
4625            "STREAM_JOB_STATUS_UNSPECIFIED",
4626            "STREAM_JOB_STATUS_CREATING",
4627            "STREAM_JOB_STATUS_CREATED",
4628        ];
4629
4630        struct GeneratedVisitor;
4631
4632        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4633            type Value = StreamJobStatus;
4634
4635            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4636                write!(formatter, "expected one of: {:?}", &FIELDS)
4637            }
4638
4639            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4640            where
4641                E: serde::de::Error,
4642            {
4643                i32::try_from(v)
4644                    .ok()
4645                    .and_then(|x| x.try_into().ok())
4646                    .ok_or_else(|| {
4647                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4648                    })
4649            }
4650
4651            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4652            where
4653                E: serde::de::Error,
4654            {
4655                i32::try_from(v)
4656                    .ok()
4657                    .and_then(|x| x.try_into().ok())
4658                    .ok_or_else(|| {
4659                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4660                    })
4661            }
4662
4663            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4664            where
4665                E: serde::de::Error,
4666            {
4667                match value {
4668                    "STREAM_JOB_STATUS_UNSPECIFIED" => Ok(StreamJobStatus::Unspecified),
4669                    "STREAM_JOB_STATUS_CREATING" => Ok(StreamJobStatus::Creating),
4670                    "STREAM_JOB_STATUS_CREATED" => Ok(StreamJobStatus::Created),
4671                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4672                }
4673            }
4674        }
4675        deserializer.deserialize_any(GeneratedVisitor)
4676    }
4677}
4678impl serde::Serialize for StreamSourceInfo {
4679    #[allow(deprecated)]
4680    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4681    where
4682        S: serde::Serializer,
4683    {
4684        use serde::ser::SerializeStruct;
4685        let mut len = 0;
4686        if self.row_format != 0 {
4687            len += 1;
4688        }
4689        if !self.row_schema_location.is_empty() {
4690            len += 1;
4691        }
4692        if self.use_schema_registry {
4693            len += 1;
4694        }
4695        if !self.proto_message_name.is_empty() {
4696            len += 1;
4697        }
4698        if self.csv_delimiter != 0 {
4699            len += 1;
4700        }
4701        if self.csv_has_header {
4702            len += 1;
4703        }
4704        if self.format != 0 {
4705            len += 1;
4706        }
4707        if self.row_encode != 0 {
4708            len += 1;
4709        }
4710        if self.name_strategy != 0 {
4711            len += 1;
4712        }
4713        if self.key_message_name.is_some() {
4714            len += 1;
4715        }
4716        if self.external_table.is_some() {
4717            len += 1;
4718        }
4719        if self.cdc_source_job {
4720            len += 1;
4721        }
4722        if self.is_distributed {
4723            len += 1;
4724        }
4725        if !self.format_encode_options.is_empty() {
4726            len += 1;
4727        }
4728        if !self.format_encode_secret_refs.is_empty() {
4729            len += 1;
4730        }
4731        if self.connection_id.is_some() {
4732            len += 1;
4733        }
4734        let mut struct_ser = serializer.serialize_struct("catalog.StreamSourceInfo", len)?;
4735        if self.row_format != 0 {
4736            let v = super::plan_common::RowFormatType::try_from(self.row_format)
4737                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_format)))?;
4738            struct_ser.serialize_field("rowFormat", &v)?;
4739        }
4740        if !self.row_schema_location.is_empty() {
4741            struct_ser.serialize_field("rowSchemaLocation", &self.row_schema_location)?;
4742        }
4743        if self.use_schema_registry {
4744            struct_ser.serialize_field("useSchemaRegistry", &self.use_schema_registry)?;
4745        }
4746        if !self.proto_message_name.is_empty() {
4747            struct_ser.serialize_field("protoMessageName", &self.proto_message_name)?;
4748        }
4749        if self.csv_delimiter != 0 {
4750            struct_ser.serialize_field("csvDelimiter", &self.csv_delimiter)?;
4751        }
4752        if self.csv_has_header {
4753            struct_ser.serialize_field("csvHasHeader", &self.csv_has_header)?;
4754        }
4755        if self.format != 0 {
4756            let v = super::plan_common::FormatType::try_from(self.format)
4757                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
4758            struct_ser.serialize_field("format", &v)?;
4759        }
4760        if self.row_encode != 0 {
4761            let v = super::plan_common::EncodeType::try_from(self.row_encode)
4762                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_encode)))?;
4763            struct_ser.serialize_field("rowEncode", &v)?;
4764        }
4765        if self.name_strategy != 0 {
4766            let v = SchemaRegistryNameStrategy::try_from(self.name_strategy)
4767                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.name_strategy)))?;
4768            struct_ser.serialize_field("nameStrategy", &v)?;
4769        }
4770        if let Some(v) = self.key_message_name.as_ref() {
4771            struct_ser.serialize_field("keyMessageName", v)?;
4772        }
4773        if let Some(v) = self.external_table.as_ref() {
4774            struct_ser.serialize_field("externalTable", v)?;
4775        }
4776        if self.cdc_source_job {
4777            struct_ser.serialize_field("cdcSourceJob", &self.cdc_source_job)?;
4778        }
4779        if self.is_distributed {
4780            struct_ser.serialize_field("isDistributed", &self.is_distributed)?;
4781        }
4782        if !self.format_encode_options.is_empty() {
4783            struct_ser.serialize_field("formatEncodeOptions", &self.format_encode_options)?;
4784        }
4785        if !self.format_encode_secret_refs.is_empty() {
4786            struct_ser.serialize_field("formatEncodeSecretRefs", &self.format_encode_secret_refs)?;
4787        }
4788        if let Some(v) = self.connection_id.as_ref() {
4789            struct_ser.serialize_field("connectionId", v)?;
4790        }
4791        struct_ser.end()
4792    }
4793}
4794impl<'de> serde::Deserialize<'de> for StreamSourceInfo {
4795    #[allow(deprecated)]
4796    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4797    where
4798        D: serde::Deserializer<'de>,
4799    {
4800        const FIELDS: &[&str] = &[
4801            "row_format",
4802            "rowFormat",
4803            "row_schema_location",
4804            "rowSchemaLocation",
4805            "use_schema_registry",
4806            "useSchemaRegistry",
4807            "proto_message_name",
4808            "protoMessageName",
4809            "csv_delimiter",
4810            "csvDelimiter",
4811            "csv_has_header",
4812            "csvHasHeader",
4813            "format",
4814            "row_encode",
4815            "rowEncode",
4816            "name_strategy",
4817            "nameStrategy",
4818            "key_message_name",
4819            "keyMessageName",
4820            "external_table",
4821            "externalTable",
4822            "cdc_source_job",
4823            "cdcSourceJob",
4824            "is_distributed",
4825            "isDistributed",
4826            "format_encode_options",
4827            "formatEncodeOptions",
4828            "format_encode_secret_refs",
4829            "formatEncodeSecretRefs",
4830            "connection_id",
4831            "connectionId",
4832        ];
4833
4834        #[allow(clippy::enum_variant_names)]
4835        enum GeneratedField {
4836            RowFormat,
4837            RowSchemaLocation,
4838            UseSchemaRegistry,
4839            ProtoMessageName,
4840            CsvDelimiter,
4841            CsvHasHeader,
4842            Format,
4843            RowEncode,
4844            NameStrategy,
4845            KeyMessageName,
4846            ExternalTable,
4847            CdcSourceJob,
4848            IsDistributed,
4849            FormatEncodeOptions,
4850            FormatEncodeSecretRefs,
4851            ConnectionId,
4852        }
4853        impl<'de> serde::Deserialize<'de> for GeneratedField {
4854            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4855            where
4856                D: serde::Deserializer<'de>,
4857            {
4858                struct GeneratedVisitor;
4859
4860                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4861                    type Value = GeneratedField;
4862
4863                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4864                        write!(formatter, "expected one of: {:?}", &FIELDS)
4865                    }
4866
4867                    #[allow(unused_variables)]
4868                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4869                    where
4870                        E: serde::de::Error,
4871                    {
4872                        match value {
4873                            "rowFormat" | "row_format" => Ok(GeneratedField::RowFormat),
4874                            "rowSchemaLocation" | "row_schema_location" => Ok(GeneratedField::RowSchemaLocation),
4875                            "useSchemaRegistry" | "use_schema_registry" => Ok(GeneratedField::UseSchemaRegistry),
4876                            "protoMessageName" | "proto_message_name" => Ok(GeneratedField::ProtoMessageName),
4877                            "csvDelimiter" | "csv_delimiter" => Ok(GeneratedField::CsvDelimiter),
4878                            "csvHasHeader" | "csv_has_header" => Ok(GeneratedField::CsvHasHeader),
4879                            "format" => Ok(GeneratedField::Format),
4880                            "rowEncode" | "row_encode" => Ok(GeneratedField::RowEncode),
4881                            "nameStrategy" | "name_strategy" => Ok(GeneratedField::NameStrategy),
4882                            "keyMessageName" | "key_message_name" => Ok(GeneratedField::KeyMessageName),
4883                            "externalTable" | "external_table" => Ok(GeneratedField::ExternalTable),
4884                            "cdcSourceJob" | "cdc_source_job" => Ok(GeneratedField::CdcSourceJob),
4885                            "isDistributed" | "is_distributed" => Ok(GeneratedField::IsDistributed),
4886                            "formatEncodeOptions" | "format_encode_options" => Ok(GeneratedField::FormatEncodeOptions),
4887                            "formatEncodeSecretRefs" | "format_encode_secret_refs" => Ok(GeneratedField::FormatEncodeSecretRefs),
4888                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4889                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4890                        }
4891                    }
4892                }
4893                deserializer.deserialize_identifier(GeneratedVisitor)
4894            }
4895        }
4896        struct GeneratedVisitor;
4897        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4898            type Value = StreamSourceInfo;
4899
4900            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4901                formatter.write_str("struct catalog.StreamSourceInfo")
4902            }
4903
4904            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSourceInfo, V::Error>
4905                where
4906                    V: serde::de::MapAccess<'de>,
4907            {
4908                let mut row_format__ = None;
4909                let mut row_schema_location__ = None;
4910                let mut use_schema_registry__ = None;
4911                let mut proto_message_name__ = None;
4912                let mut csv_delimiter__ = None;
4913                let mut csv_has_header__ = None;
4914                let mut format__ = None;
4915                let mut row_encode__ = None;
4916                let mut name_strategy__ = None;
4917                let mut key_message_name__ = None;
4918                let mut external_table__ = None;
4919                let mut cdc_source_job__ = None;
4920                let mut is_distributed__ = None;
4921                let mut format_encode_options__ = None;
4922                let mut format_encode_secret_refs__ = None;
4923                let mut connection_id__ = None;
4924                while let Some(k) = map_.next_key()? {
4925                    match k {
4926                        GeneratedField::RowFormat => {
4927                            if row_format__.is_some() {
4928                                return Err(serde::de::Error::duplicate_field("rowFormat"));
4929                            }
4930                            row_format__ = Some(map_.next_value::<super::plan_common::RowFormatType>()? as i32);
4931                        }
4932                        GeneratedField::RowSchemaLocation => {
4933                            if row_schema_location__.is_some() {
4934                                return Err(serde::de::Error::duplicate_field("rowSchemaLocation"));
4935                            }
4936                            row_schema_location__ = Some(map_.next_value()?);
4937                        }
4938                        GeneratedField::UseSchemaRegistry => {
4939                            if use_schema_registry__.is_some() {
4940                                return Err(serde::de::Error::duplicate_field("useSchemaRegistry"));
4941                            }
4942                            use_schema_registry__ = Some(map_.next_value()?);
4943                        }
4944                        GeneratedField::ProtoMessageName => {
4945                            if proto_message_name__.is_some() {
4946                                return Err(serde::de::Error::duplicate_field("protoMessageName"));
4947                            }
4948                            proto_message_name__ = Some(map_.next_value()?);
4949                        }
4950                        GeneratedField::CsvDelimiter => {
4951                            if csv_delimiter__.is_some() {
4952                                return Err(serde::de::Error::duplicate_field("csvDelimiter"));
4953                            }
4954                            csv_delimiter__ = 
4955                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4956                            ;
4957                        }
4958                        GeneratedField::CsvHasHeader => {
4959                            if csv_has_header__.is_some() {
4960                                return Err(serde::de::Error::duplicate_field("csvHasHeader"));
4961                            }
4962                            csv_has_header__ = Some(map_.next_value()?);
4963                        }
4964                        GeneratedField::Format => {
4965                            if format__.is_some() {
4966                                return Err(serde::de::Error::duplicate_field("format"));
4967                            }
4968                            format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
4969                        }
4970                        GeneratedField::RowEncode => {
4971                            if row_encode__.is_some() {
4972                                return Err(serde::de::Error::duplicate_field("rowEncode"));
4973                            }
4974                            row_encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
4975                        }
4976                        GeneratedField::NameStrategy => {
4977                            if name_strategy__.is_some() {
4978                                return Err(serde::de::Error::duplicate_field("nameStrategy"));
4979                            }
4980                            name_strategy__ = Some(map_.next_value::<SchemaRegistryNameStrategy>()? as i32);
4981                        }
4982                        GeneratedField::KeyMessageName => {
4983                            if key_message_name__.is_some() {
4984                                return Err(serde::de::Error::duplicate_field("keyMessageName"));
4985                            }
4986                            key_message_name__ = map_.next_value()?;
4987                        }
4988                        GeneratedField::ExternalTable => {
4989                            if external_table__.is_some() {
4990                                return Err(serde::de::Error::duplicate_field("externalTable"));
4991                            }
4992                            external_table__ = map_.next_value()?;
4993                        }
4994                        GeneratedField::CdcSourceJob => {
4995                            if cdc_source_job__.is_some() {
4996                                return Err(serde::de::Error::duplicate_field("cdcSourceJob"));
4997                            }
4998                            cdc_source_job__ = Some(map_.next_value()?);
4999                        }
5000                        GeneratedField::IsDistributed => {
5001                            if is_distributed__.is_some() {
5002                                return Err(serde::de::Error::duplicate_field("isDistributed"));
5003                            }
5004                            is_distributed__ = Some(map_.next_value()?);
5005                        }
5006                        GeneratedField::FormatEncodeOptions => {
5007                            if format_encode_options__.is_some() {
5008                                return Err(serde::de::Error::duplicate_field("formatEncodeOptions"));
5009                            }
5010                            format_encode_options__ = Some(
5011                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
5012                            );
5013                        }
5014                        GeneratedField::FormatEncodeSecretRefs => {
5015                            if format_encode_secret_refs__.is_some() {
5016                                return Err(serde::de::Error::duplicate_field("formatEncodeSecretRefs"));
5017                            }
5018                            format_encode_secret_refs__ = Some(
5019                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
5020                            );
5021                        }
5022                        GeneratedField::ConnectionId => {
5023                            if connection_id__.is_some() {
5024                                return Err(serde::de::Error::duplicate_field("connectionId"));
5025                            }
5026                            connection_id__ = 
5027                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5028                            ;
5029                        }
5030                    }
5031                }
5032                Ok(StreamSourceInfo {
5033                    row_format: row_format__.unwrap_or_default(),
5034                    row_schema_location: row_schema_location__.unwrap_or_default(),
5035                    use_schema_registry: use_schema_registry__.unwrap_or_default(),
5036                    proto_message_name: proto_message_name__.unwrap_or_default(),
5037                    csv_delimiter: csv_delimiter__.unwrap_or_default(),
5038                    csv_has_header: csv_has_header__.unwrap_or_default(),
5039                    format: format__.unwrap_or_default(),
5040                    row_encode: row_encode__.unwrap_or_default(),
5041                    name_strategy: name_strategy__.unwrap_or_default(),
5042                    key_message_name: key_message_name__,
5043                    external_table: external_table__,
5044                    cdc_source_job: cdc_source_job__.unwrap_or_default(),
5045                    is_distributed: is_distributed__.unwrap_or_default(),
5046                    format_encode_options: format_encode_options__.unwrap_or_default(),
5047                    format_encode_secret_refs: format_encode_secret_refs__.unwrap_or_default(),
5048                    connection_id: connection_id__,
5049                })
5050            }
5051        }
5052        deserializer.deserialize_struct("catalog.StreamSourceInfo", FIELDS, GeneratedVisitor)
5053    }
5054}
5055impl serde::Serialize for Subscription {
5056    #[allow(deprecated)]
5057    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5058    where
5059        S: serde::Serializer,
5060    {
5061        use serde::ser::SerializeStruct;
5062        let mut len = 0;
5063        if self.id != 0 {
5064            len += 1;
5065        }
5066        if !self.name.is_empty() {
5067            len += 1;
5068        }
5069        if !self.definition.is_empty() {
5070            len += 1;
5071        }
5072        if self.retention_seconds != 0 {
5073            len += 1;
5074        }
5075        if self.database_id != 0 {
5076            len += 1;
5077        }
5078        if self.schema_id != 0 {
5079            len += 1;
5080        }
5081        if self.dependent_table_id != 0 {
5082            len += 1;
5083        }
5084        if self.initialized_at_epoch.is_some() {
5085            len += 1;
5086        }
5087        if self.created_at_epoch.is_some() {
5088            len += 1;
5089        }
5090        if self.owner != 0 {
5091            len += 1;
5092        }
5093        if self.initialized_at_cluster_version.is_some() {
5094            len += 1;
5095        }
5096        if self.created_at_cluster_version.is_some() {
5097            len += 1;
5098        }
5099        if self.subscription_state != 0 {
5100            len += 1;
5101        }
5102        let mut struct_ser = serializer.serialize_struct("catalog.Subscription", len)?;
5103        if self.id != 0 {
5104            struct_ser.serialize_field("id", &self.id)?;
5105        }
5106        if !self.name.is_empty() {
5107            struct_ser.serialize_field("name", &self.name)?;
5108        }
5109        if !self.definition.is_empty() {
5110            struct_ser.serialize_field("definition", &self.definition)?;
5111        }
5112        if self.retention_seconds != 0 {
5113            #[allow(clippy::needless_borrow)]
5114            #[allow(clippy::needless_borrows_for_generic_args)]
5115            struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
5116        }
5117        if self.database_id != 0 {
5118            struct_ser.serialize_field("databaseId", &self.database_id)?;
5119        }
5120        if self.schema_id != 0 {
5121            struct_ser.serialize_field("schemaId", &self.schema_id)?;
5122        }
5123        if self.dependent_table_id != 0 {
5124            struct_ser.serialize_field("dependentTableId", &self.dependent_table_id)?;
5125        }
5126        if let Some(v) = self.initialized_at_epoch.as_ref() {
5127            #[allow(clippy::needless_borrow)]
5128            #[allow(clippy::needless_borrows_for_generic_args)]
5129            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5130        }
5131        if let Some(v) = self.created_at_epoch.as_ref() {
5132            #[allow(clippy::needless_borrow)]
5133            #[allow(clippy::needless_borrows_for_generic_args)]
5134            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5135        }
5136        if self.owner != 0 {
5137            struct_ser.serialize_field("owner", &self.owner)?;
5138        }
5139        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5140            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5141        }
5142        if let Some(v) = self.created_at_cluster_version.as_ref() {
5143            struct_ser.serialize_field("createdAtClusterVersion", v)?;
5144        }
5145        if self.subscription_state != 0 {
5146            let v = subscription::SubscriptionState::try_from(self.subscription_state)
5147                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscription_state)))?;
5148            struct_ser.serialize_field("subscriptionState", &v)?;
5149        }
5150        struct_ser.end()
5151    }
5152}
5153impl<'de> serde::Deserialize<'de> for Subscription {
5154    #[allow(deprecated)]
5155    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5156    where
5157        D: serde::Deserializer<'de>,
5158    {
5159        const FIELDS: &[&str] = &[
5160            "id",
5161            "name",
5162            "definition",
5163            "retention_seconds",
5164            "retentionSeconds",
5165            "database_id",
5166            "databaseId",
5167            "schema_id",
5168            "schemaId",
5169            "dependent_table_id",
5170            "dependentTableId",
5171            "initialized_at_epoch",
5172            "initializedAtEpoch",
5173            "created_at_epoch",
5174            "createdAtEpoch",
5175            "owner",
5176            "initialized_at_cluster_version",
5177            "initializedAtClusterVersion",
5178            "created_at_cluster_version",
5179            "createdAtClusterVersion",
5180            "subscription_state",
5181            "subscriptionState",
5182        ];
5183
5184        #[allow(clippy::enum_variant_names)]
5185        enum GeneratedField {
5186            Id,
5187            Name,
5188            Definition,
5189            RetentionSeconds,
5190            DatabaseId,
5191            SchemaId,
5192            DependentTableId,
5193            InitializedAtEpoch,
5194            CreatedAtEpoch,
5195            Owner,
5196            InitializedAtClusterVersion,
5197            CreatedAtClusterVersion,
5198            SubscriptionState,
5199        }
5200        impl<'de> serde::Deserialize<'de> for GeneratedField {
5201            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5202            where
5203                D: serde::Deserializer<'de>,
5204            {
5205                struct GeneratedVisitor;
5206
5207                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5208                    type Value = GeneratedField;
5209
5210                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5211                        write!(formatter, "expected one of: {:?}", &FIELDS)
5212                    }
5213
5214                    #[allow(unused_variables)]
5215                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5216                    where
5217                        E: serde::de::Error,
5218                    {
5219                        match value {
5220                            "id" => Ok(GeneratedField::Id),
5221                            "name" => Ok(GeneratedField::Name),
5222                            "definition" => Ok(GeneratedField::Definition),
5223                            "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5224                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5225                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5226                            "dependentTableId" | "dependent_table_id" => Ok(GeneratedField::DependentTableId),
5227                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5228                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5229                            "owner" => Ok(GeneratedField::Owner),
5230                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5231                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5232                            "subscriptionState" | "subscription_state" => Ok(GeneratedField::SubscriptionState),
5233                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5234                        }
5235                    }
5236                }
5237                deserializer.deserialize_identifier(GeneratedVisitor)
5238            }
5239        }
5240        struct GeneratedVisitor;
5241        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5242            type Value = Subscription;
5243
5244            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5245                formatter.write_str("struct catalog.Subscription")
5246            }
5247
5248            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Subscription, V::Error>
5249                where
5250                    V: serde::de::MapAccess<'de>,
5251            {
5252                let mut id__ = None;
5253                let mut name__ = None;
5254                let mut definition__ = None;
5255                let mut retention_seconds__ = None;
5256                let mut database_id__ = None;
5257                let mut schema_id__ = None;
5258                let mut dependent_table_id__ = None;
5259                let mut initialized_at_epoch__ = None;
5260                let mut created_at_epoch__ = None;
5261                let mut owner__ = None;
5262                let mut initialized_at_cluster_version__ = None;
5263                let mut created_at_cluster_version__ = None;
5264                let mut subscription_state__ = None;
5265                while let Some(k) = map_.next_key()? {
5266                    match k {
5267                        GeneratedField::Id => {
5268                            if id__.is_some() {
5269                                return Err(serde::de::Error::duplicate_field("id"));
5270                            }
5271                            id__ = 
5272                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5273                            ;
5274                        }
5275                        GeneratedField::Name => {
5276                            if name__.is_some() {
5277                                return Err(serde::de::Error::duplicate_field("name"));
5278                            }
5279                            name__ = Some(map_.next_value()?);
5280                        }
5281                        GeneratedField::Definition => {
5282                            if definition__.is_some() {
5283                                return Err(serde::de::Error::duplicate_field("definition"));
5284                            }
5285                            definition__ = Some(map_.next_value()?);
5286                        }
5287                        GeneratedField::RetentionSeconds => {
5288                            if retention_seconds__.is_some() {
5289                                return Err(serde::de::Error::duplicate_field("retentionSeconds"));
5290                            }
5291                            retention_seconds__ = 
5292                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5293                            ;
5294                        }
5295                        GeneratedField::DatabaseId => {
5296                            if database_id__.is_some() {
5297                                return Err(serde::de::Error::duplicate_field("databaseId"));
5298                            }
5299                            database_id__ = 
5300                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5301                            ;
5302                        }
5303                        GeneratedField::SchemaId => {
5304                            if schema_id__.is_some() {
5305                                return Err(serde::de::Error::duplicate_field("schemaId"));
5306                            }
5307                            schema_id__ = 
5308                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5309                            ;
5310                        }
5311                        GeneratedField::DependentTableId => {
5312                            if dependent_table_id__.is_some() {
5313                                return Err(serde::de::Error::duplicate_field("dependentTableId"));
5314                            }
5315                            dependent_table_id__ = 
5316                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5317                            ;
5318                        }
5319                        GeneratedField::InitializedAtEpoch => {
5320                            if initialized_at_epoch__.is_some() {
5321                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
5322                            }
5323                            initialized_at_epoch__ = 
5324                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5325                            ;
5326                        }
5327                        GeneratedField::CreatedAtEpoch => {
5328                            if created_at_epoch__.is_some() {
5329                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
5330                            }
5331                            created_at_epoch__ = 
5332                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5333                            ;
5334                        }
5335                        GeneratedField::Owner => {
5336                            if owner__.is_some() {
5337                                return Err(serde::de::Error::duplicate_field("owner"));
5338                            }
5339                            owner__ = 
5340                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5341                            ;
5342                        }
5343                        GeneratedField::InitializedAtClusterVersion => {
5344                            if initialized_at_cluster_version__.is_some() {
5345                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
5346                            }
5347                            initialized_at_cluster_version__ = map_.next_value()?;
5348                        }
5349                        GeneratedField::CreatedAtClusterVersion => {
5350                            if created_at_cluster_version__.is_some() {
5351                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
5352                            }
5353                            created_at_cluster_version__ = map_.next_value()?;
5354                        }
5355                        GeneratedField::SubscriptionState => {
5356                            if subscription_state__.is_some() {
5357                                return Err(serde::de::Error::duplicate_field("subscriptionState"));
5358                            }
5359                            subscription_state__ = Some(map_.next_value::<subscription::SubscriptionState>()? as i32);
5360                        }
5361                    }
5362                }
5363                Ok(Subscription {
5364                    id: id__.unwrap_or_default(),
5365                    name: name__.unwrap_or_default(),
5366                    definition: definition__.unwrap_or_default(),
5367                    retention_seconds: retention_seconds__.unwrap_or_default(),
5368                    database_id: database_id__.unwrap_or_default(),
5369                    schema_id: schema_id__.unwrap_or_default(),
5370                    dependent_table_id: dependent_table_id__.unwrap_or_default(),
5371                    initialized_at_epoch: initialized_at_epoch__,
5372                    created_at_epoch: created_at_epoch__,
5373                    owner: owner__.unwrap_or_default(),
5374                    initialized_at_cluster_version: initialized_at_cluster_version__,
5375                    created_at_cluster_version: created_at_cluster_version__,
5376                    subscription_state: subscription_state__.unwrap_or_default(),
5377                })
5378            }
5379        }
5380        deserializer.deserialize_struct("catalog.Subscription", FIELDS, GeneratedVisitor)
5381    }
5382}
5383impl serde::Serialize for subscription::SubscriptionState {
5384    #[allow(deprecated)]
5385    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5386    where
5387        S: serde::Serializer,
5388    {
5389        let variant = match self {
5390            Self::Unspecified => "UNSPECIFIED",
5391            Self::Init => "INIT",
5392            Self::Created => "CREATED",
5393        };
5394        serializer.serialize_str(variant)
5395    }
5396}
5397impl<'de> serde::Deserialize<'de> for subscription::SubscriptionState {
5398    #[allow(deprecated)]
5399    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5400    where
5401        D: serde::Deserializer<'de>,
5402    {
5403        const FIELDS: &[&str] = &[
5404            "UNSPECIFIED",
5405            "INIT",
5406            "CREATED",
5407        ];
5408
5409        struct GeneratedVisitor;
5410
5411        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5412            type Value = subscription::SubscriptionState;
5413
5414            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5415                write!(formatter, "expected one of: {:?}", &FIELDS)
5416            }
5417
5418            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5419            where
5420                E: serde::de::Error,
5421            {
5422                i32::try_from(v)
5423                    .ok()
5424                    .and_then(|x| x.try_into().ok())
5425                    .ok_or_else(|| {
5426                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5427                    })
5428            }
5429
5430            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5431            where
5432                E: serde::de::Error,
5433            {
5434                i32::try_from(v)
5435                    .ok()
5436                    .and_then(|x| x.try_into().ok())
5437                    .ok_or_else(|| {
5438                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5439                    })
5440            }
5441
5442            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5443            where
5444                E: serde::de::Error,
5445            {
5446                match value {
5447                    "UNSPECIFIED" => Ok(subscription::SubscriptionState::Unspecified),
5448                    "INIT" => Ok(subscription::SubscriptionState::Init),
5449                    "CREATED" => Ok(subscription::SubscriptionState::Created),
5450                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5451                }
5452            }
5453        }
5454        deserializer.deserialize_any(GeneratedVisitor)
5455    }
5456}
5457impl serde::Serialize for Table {
5458    #[allow(deprecated)]
5459    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5460    where
5461        S: serde::Serializer,
5462    {
5463        use serde::ser::SerializeStruct;
5464        let mut len = 0;
5465        if self.id != 0 {
5466            len += 1;
5467        }
5468        if self.schema_id != 0 {
5469            len += 1;
5470        }
5471        if self.database_id != 0 {
5472            len += 1;
5473        }
5474        if !self.name.is_empty() {
5475            len += 1;
5476        }
5477        if !self.columns.is_empty() {
5478            len += 1;
5479        }
5480        if !self.pk.is_empty() {
5481            len += 1;
5482        }
5483        if self.table_type != 0 {
5484            len += 1;
5485        }
5486        if !self.distribution_key.is_empty() {
5487            len += 1;
5488        }
5489        if !self.stream_key.is_empty() {
5490            len += 1;
5491        }
5492        if self.append_only {
5493            len += 1;
5494        }
5495        if self.owner != 0 {
5496            len += 1;
5497        }
5498        if self.fragment_id != 0 {
5499            len += 1;
5500        }
5501        if self.vnode_col_index.is_some() {
5502            len += 1;
5503        }
5504        if self.row_id_index.is_some() {
5505            len += 1;
5506        }
5507        if !self.value_indices.is_empty() {
5508            len += 1;
5509        }
5510        if !self.definition.is_empty() {
5511            len += 1;
5512        }
5513        if self.handle_pk_conflict_behavior != 0 {
5514            len += 1;
5515        }
5516        if self.read_prefix_len_hint != 0 {
5517            len += 1;
5518        }
5519        if !self.watermark_indices.is_empty() {
5520            len += 1;
5521        }
5522        if !self.dist_key_in_pk.is_empty() {
5523            len += 1;
5524        }
5525        if self.dml_fragment_id.is_some() {
5526            len += 1;
5527        }
5528        if self.cardinality.is_some() {
5529            len += 1;
5530        }
5531        if self.initialized_at_epoch.is_some() {
5532            len += 1;
5533        }
5534        if self.created_at_epoch.is_some() {
5535            len += 1;
5536        }
5537        if self.cleaned_by_watermark {
5538            len += 1;
5539        }
5540        if self.stream_job_status != 0 {
5541            len += 1;
5542        }
5543        if self.create_type != 0 {
5544            len += 1;
5545        }
5546        if self.description.is_some() {
5547            len += 1;
5548        }
5549        if !self.incoming_sinks.is_empty() {
5550            len += 1;
5551        }
5552        if self.initialized_at_cluster_version.is_some() {
5553            len += 1;
5554        }
5555        if self.created_at_cluster_version.is_some() {
5556            len += 1;
5557        }
5558        if self.retention_seconds.is_some() {
5559            len += 1;
5560        }
5561        if !self.version_column_indices.is_empty() {
5562            len += 1;
5563        }
5564        if self.cdc_table_id.is_some() {
5565            len += 1;
5566        }
5567        if self.maybe_vnode_count.is_some() {
5568            len += 1;
5569        }
5570        if self.webhook_info.is_some() {
5571            len += 1;
5572        }
5573        if self.job_id.is_some() {
5574            len += 1;
5575        }
5576        if self.engine.is_some() {
5577            len += 1;
5578        }
5579        if self.clean_watermark_index_in_pk.is_some() {
5580            len += 1;
5581        }
5582        if self.refreshable {
5583            len += 1;
5584        }
5585        if self.vector_index_info.is_some() {
5586            len += 1;
5587        }
5588        if self.cdc_table_type.is_some() {
5589            len += 1;
5590        }
5591        if self.refresh_state.is_some() {
5592            len += 1;
5593        }
5594        if self.version.is_some() {
5595            len += 1;
5596        }
5597        if self.optional_associated_source_id.is_some() {
5598            len += 1;
5599        }
5600        let mut struct_ser = serializer.serialize_struct("catalog.Table", len)?;
5601        if self.id != 0 {
5602            struct_ser.serialize_field("id", &self.id)?;
5603        }
5604        if self.schema_id != 0 {
5605            struct_ser.serialize_field("schemaId", &self.schema_id)?;
5606        }
5607        if self.database_id != 0 {
5608            struct_ser.serialize_field("databaseId", &self.database_id)?;
5609        }
5610        if !self.name.is_empty() {
5611            struct_ser.serialize_field("name", &self.name)?;
5612        }
5613        if !self.columns.is_empty() {
5614            struct_ser.serialize_field("columns", &self.columns)?;
5615        }
5616        if !self.pk.is_empty() {
5617            struct_ser.serialize_field("pk", &self.pk)?;
5618        }
5619        if self.table_type != 0 {
5620            let v = table::TableType::try_from(self.table_type)
5621                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
5622            struct_ser.serialize_field("tableType", &v)?;
5623        }
5624        if !self.distribution_key.is_empty() {
5625            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
5626        }
5627        if !self.stream_key.is_empty() {
5628            struct_ser.serialize_field("streamKey", &self.stream_key)?;
5629        }
5630        if self.append_only {
5631            struct_ser.serialize_field("appendOnly", &self.append_only)?;
5632        }
5633        if self.owner != 0 {
5634            struct_ser.serialize_field("owner", &self.owner)?;
5635        }
5636        if self.fragment_id != 0 {
5637            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5638        }
5639        if let Some(v) = self.vnode_col_index.as_ref() {
5640            struct_ser.serialize_field("vnodeColIndex", v)?;
5641        }
5642        if let Some(v) = self.row_id_index.as_ref() {
5643            struct_ser.serialize_field("rowIdIndex", v)?;
5644        }
5645        if !self.value_indices.is_empty() {
5646            struct_ser.serialize_field("valueIndices", &self.value_indices)?;
5647        }
5648        if !self.definition.is_empty() {
5649            struct_ser.serialize_field("definition", &self.definition)?;
5650        }
5651        if self.handle_pk_conflict_behavior != 0 {
5652            let v = HandleConflictBehavior::try_from(self.handle_pk_conflict_behavior)
5653                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.handle_pk_conflict_behavior)))?;
5654            struct_ser.serialize_field("handlePkConflictBehavior", &v)?;
5655        }
5656        if self.read_prefix_len_hint != 0 {
5657            struct_ser.serialize_field("readPrefixLenHint", &self.read_prefix_len_hint)?;
5658        }
5659        if !self.watermark_indices.is_empty() {
5660            struct_ser.serialize_field("watermarkIndices", &self.watermark_indices)?;
5661        }
5662        if !self.dist_key_in_pk.is_empty() {
5663            struct_ser.serialize_field("distKeyInPk", &self.dist_key_in_pk)?;
5664        }
5665        if let Some(v) = self.dml_fragment_id.as_ref() {
5666            struct_ser.serialize_field("dmlFragmentId", v)?;
5667        }
5668        if let Some(v) = self.cardinality.as_ref() {
5669            struct_ser.serialize_field("cardinality", v)?;
5670        }
5671        if let Some(v) = self.initialized_at_epoch.as_ref() {
5672            #[allow(clippy::needless_borrow)]
5673            #[allow(clippy::needless_borrows_for_generic_args)]
5674            struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5675        }
5676        if let Some(v) = self.created_at_epoch.as_ref() {
5677            #[allow(clippy::needless_borrow)]
5678            #[allow(clippy::needless_borrows_for_generic_args)]
5679            struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5680        }
5681        if self.cleaned_by_watermark {
5682            struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
5683        }
5684        if self.stream_job_status != 0 {
5685            let v = StreamJobStatus::try_from(self.stream_job_status)
5686                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
5687            struct_ser.serialize_field("streamJobStatus", &v)?;
5688        }
5689        if self.create_type != 0 {
5690            let v = CreateType::try_from(self.create_type)
5691                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
5692            struct_ser.serialize_field("createType", &v)?;
5693        }
5694        if let Some(v) = self.description.as_ref() {
5695            struct_ser.serialize_field("description", v)?;
5696        }
5697        if !self.incoming_sinks.is_empty() {
5698            struct_ser.serialize_field("incomingSinks", &self.incoming_sinks)?;
5699        }
5700        if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5701            struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5702        }
5703        if let Some(v) = self.created_at_cluster_version.as_ref() {
5704            struct_ser.serialize_field("createdAtClusterVersion", v)?;
5705        }
5706        if let Some(v) = self.retention_seconds.as_ref() {
5707            struct_ser.serialize_field("retentionSeconds", v)?;
5708        }
5709        if !self.version_column_indices.is_empty() {
5710            struct_ser.serialize_field("versionColumnIndices", &self.version_column_indices)?;
5711        }
5712        if let Some(v) = self.cdc_table_id.as_ref() {
5713            struct_ser.serialize_field("cdcTableId", v)?;
5714        }
5715        if let Some(v) = self.maybe_vnode_count.as_ref() {
5716            struct_ser.serialize_field("maybeVnodeCount", v)?;
5717        }
5718        if let Some(v) = self.webhook_info.as_ref() {
5719            struct_ser.serialize_field("webhookInfo", v)?;
5720        }
5721        if let Some(v) = self.job_id.as_ref() {
5722            struct_ser.serialize_field("jobId", v)?;
5723        }
5724        if let Some(v) = self.engine.as_ref() {
5725            let v = table::Engine::try_from(*v)
5726                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5727            struct_ser.serialize_field("engine", &v)?;
5728        }
5729        if let Some(v) = self.clean_watermark_index_in_pk.as_ref() {
5730            struct_ser.serialize_field("cleanWatermarkIndexInPk", v)?;
5731        }
5732        if self.refreshable {
5733            struct_ser.serialize_field("refreshable", &self.refreshable)?;
5734        }
5735        if let Some(v) = self.vector_index_info.as_ref() {
5736            struct_ser.serialize_field("vectorIndexInfo", v)?;
5737        }
5738        if let Some(v) = self.cdc_table_type.as_ref() {
5739            let v = table::CdcTableType::try_from(*v)
5740                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5741            struct_ser.serialize_field("cdcTableType", &v)?;
5742        }
5743        if let Some(v) = self.refresh_state.as_ref() {
5744            let v = RefreshState::try_from(*v)
5745                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5746            struct_ser.serialize_field("refreshState", &v)?;
5747        }
5748        if let Some(v) = self.version.as_ref() {
5749            struct_ser.serialize_field("version", v)?;
5750        }
5751        if let Some(v) = self.optional_associated_source_id.as_ref() {
5752            match v {
5753                table::OptionalAssociatedSourceId::AssociatedSourceId(v) => {
5754                    struct_ser.serialize_field("associatedSourceId", v)?;
5755                }
5756            }
5757        }
5758        struct_ser.end()
5759    }
5760}
5761impl<'de> serde::Deserialize<'de> for Table {
5762    #[allow(deprecated)]
5763    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5764    where
5765        D: serde::Deserializer<'de>,
5766    {
5767        const FIELDS: &[&str] = &[
5768            "id",
5769            "schema_id",
5770            "schemaId",
5771            "database_id",
5772            "databaseId",
5773            "name",
5774            "columns",
5775            "pk",
5776            "table_type",
5777            "tableType",
5778            "distribution_key",
5779            "distributionKey",
5780            "stream_key",
5781            "streamKey",
5782            "append_only",
5783            "appendOnly",
5784            "owner",
5785            "fragment_id",
5786            "fragmentId",
5787            "vnode_col_index",
5788            "vnodeColIndex",
5789            "row_id_index",
5790            "rowIdIndex",
5791            "value_indices",
5792            "valueIndices",
5793            "definition",
5794            "handle_pk_conflict_behavior",
5795            "handlePkConflictBehavior",
5796            "read_prefix_len_hint",
5797            "readPrefixLenHint",
5798            "watermark_indices",
5799            "watermarkIndices",
5800            "dist_key_in_pk",
5801            "distKeyInPk",
5802            "dml_fragment_id",
5803            "dmlFragmentId",
5804            "cardinality",
5805            "initialized_at_epoch",
5806            "initializedAtEpoch",
5807            "created_at_epoch",
5808            "createdAtEpoch",
5809            "cleaned_by_watermark",
5810            "cleanedByWatermark",
5811            "stream_job_status",
5812            "streamJobStatus",
5813            "create_type",
5814            "createType",
5815            "description",
5816            "incoming_sinks",
5817            "incomingSinks",
5818            "initialized_at_cluster_version",
5819            "initializedAtClusterVersion",
5820            "created_at_cluster_version",
5821            "createdAtClusterVersion",
5822            "retention_seconds",
5823            "retentionSeconds",
5824            "version_column_indices",
5825            "versionColumnIndices",
5826            "cdc_table_id",
5827            "cdcTableId",
5828            "maybe_vnode_count",
5829            "maybeVnodeCount",
5830            "webhook_info",
5831            "webhookInfo",
5832            "job_id",
5833            "jobId",
5834            "engine",
5835            "clean_watermark_index_in_pk",
5836            "cleanWatermarkIndexInPk",
5837            "refreshable",
5838            "vector_index_info",
5839            "vectorIndexInfo",
5840            "cdc_table_type",
5841            "cdcTableType",
5842            "refresh_state",
5843            "refreshState",
5844            "version",
5845            "associated_source_id",
5846            "associatedSourceId",
5847        ];
5848
5849        #[allow(clippy::enum_variant_names)]
5850        enum GeneratedField {
5851            Id,
5852            SchemaId,
5853            DatabaseId,
5854            Name,
5855            Columns,
5856            Pk,
5857            TableType,
5858            DistributionKey,
5859            StreamKey,
5860            AppendOnly,
5861            Owner,
5862            FragmentId,
5863            VnodeColIndex,
5864            RowIdIndex,
5865            ValueIndices,
5866            Definition,
5867            HandlePkConflictBehavior,
5868            ReadPrefixLenHint,
5869            WatermarkIndices,
5870            DistKeyInPk,
5871            DmlFragmentId,
5872            Cardinality,
5873            InitializedAtEpoch,
5874            CreatedAtEpoch,
5875            CleanedByWatermark,
5876            StreamJobStatus,
5877            CreateType,
5878            Description,
5879            IncomingSinks,
5880            InitializedAtClusterVersion,
5881            CreatedAtClusterVersion,
5882            RetentionSeconds,
5883            VersionColumnIndices,
5884            CdcTableId,
5885            MaybeVnodeCount,
5886            WebhookInfo,
5887            JobId,
5888            Engine,
5889            CleanWatermarkIndexInPk,
5890            Refreshable,
5891            VectorIndexInfo,
5892            CdcTableType,
5893            RefreshState,
5894            Version,
5895            AssociatedSourceId,
5896        }
5897        impl<'de> serde::Deserialize<'de> for GeneratedField {
5898            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5899            where
5900                D: serde::Deserializer<'de>,
5901            {
5902                struct GeneratedVisitor;
5903
5904                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5905                    type Value = GeneratedField;
5906
5907                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5908                        write!(formatter, "expected one of: {:?}", &FIELDS)
5909                    }
5910
5911                    #[allow(unused_variables)]
5912                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5913                    where
5914                        E: serde::de::Error,
5915                    {
5916                        match value {
5917                            "id" => Ok(GeneratedField::Id),
5918                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5919                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5920                            "name" => Ok(GeneratedField::Name),
5921                            "columns" => Ok(GeneratedField::Columns),
5922                            "pk" => Ok(GeneratedField::Pk),
5923                            "tableType" | "table_type" => Ok(GeneratedField::TableType),
5924                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
5925                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5926                            "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
5927                            "owner" => Ok(GeneratedField::Owner),
5928                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5929                            "vnodeColIndex" | "vnode_col_index" => Ok(GeneratedField::VnodeColIndex),
5930                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
5931                            "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
5932                            "definition" => Ok(GeneratedField::Definition),
5933                            "handlePkConflictBehavior" | "handle_pk_conflict_behavior" => Ok(GeneratedField::HandlePkConflictBehavior),
5934                            "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
5935                            "watermarkIndices" | "watermark_indices" => Ok(GeneratedField::WatermarkIndices),
5936                            "distKeyInPk" | "dist_key_in_pk" => Ok(GeneratedField::DistKeyInPk),
5937                            "dmlFragmentId" | "dml_fragment_id" => Ok(GeneratedField::DmlFragmentId),
5938                            "cardinality" => Ok(GeneratedField::Cardinality),
5939                            "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5940                            "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5941                            "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
5942                            "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
5943                            "createType" | "create_type" => Ok(GeneratedField::CreateType),
5944                            "description" => Ok(GeneratedField::Description),
5945                            "incomingSinks" | "incoming_sinks" => Ok(GeneratedField::IncomingSinks),
5946                            "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5947                            "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5948                            "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5949                            "versionColumnIndices" | "version_column_indices" => Ok(GeneratedField::VersionColumnIndices),
5950                            "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
5951                            "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
5952                            "webhookInfo" | "webhook_info" => Ok(GeneratedField::WebhookInfo),
5953                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
5954                            "engine" => Ok(GeneratedField::Engine),
5955                            "cleanWatermarkIndexInPk" | "clean_watermark_index_in_pk" => Ok(GeneratedField::CleanWatermarkIndexInPk),
5956                            "refreshable" => Ok(GeneratedField::Refreshable),
5957                            "vectorIndexInfo" | "vector_index_info" => Ok(GeneratedField::VectorIndexInfo),
5958                            "cdcTableType" | "cdc_table_type" => Ok(GeneratedField::CdcTableType),
5959                            "refreshState" | "refresh_state" => Ok(GeneratedField::RefreshState),
5960                            "version" => Ok(GeneratedField::Version),
5961                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
5962                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5963                        }
5964                    }
5965                }
5966                deserializer.deserialize_identifier(GeneratedVisitor)
5967            }
5968        }
5969        struct GeneratedVisitor;
5970        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5971            type Value = Table;
5972
5973            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5974                formatter.write_str("struct catalog.Table")
5975            }
5976
5977            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
5978                where
5979                    V: serde::de::MapAccess<'de>,
5980            {
5981                let mut id__ = None;
5982                let mut schema_id__ = None;
5983                let mut database_id__ = None;
5984                let mut name__ = None;
5985                let mut columns__ = None;
5986                let mut pk__ = None;
5987                let mut table_type__ = None;
5988                let mut distribution_key__ = None;
5989                let mut stream_key__ = None;
5990                let mut append_only__ = None;
5991                let mut owner__ = None;
5992                let mut fragment_id__ = None;
5993                let mut vnode_col_index__ = None;
5994                let mut row_id_index__ = None;
5995                let mut value_indices__ = None;
5996                let mut definition__ = None;
5997                let mut handle_pk_conflict_behavior__ = None;
5998                let mut read_prefix_len_hint__ = None;
5999                let mut watermark_indices__ = None;
6000                let mut dist_key_in_pk__ = None;
6001                let mut dml_fragment_id__ = None;
6002                let mut cardinality__ = None;
6003                let mut initialized_at_epoch__ = None;
6004                let mut created_at_epoch__ = None;
6005                let mut cleaned_by_watermark__ = None;
6006                let mut stream_job_status__ = None;
6007                let mut create_type__ = None;
6008                let mut description__ = None;
6009                let mut incoming_sinks__ = None;
6010                let mut initialized_at_cluster_version__ = None;
6011                let mut created_at_cluster_version__ = None;
6012                let mut retention_seconds__ = None;
6013                let mut version_column_indices__ = None;
6014                let mut cdc_table_id__ = None;
6015                let mut maybe_vnode_count__ = None;
6016                let mut webhook_info__ = None;
6017                let mut job_id__ = None;
6018                let mut engine__ = None;
6019                let mut clean_watermark_index_in_pk__ = None;
6020                let mut refreshable__ = None;
6021                let mut vector_index_info__ = None;
6022                let mut cdc_table_type__ = None;
6023                let mut refresh_state__ = None;
6024                let mut version__ = None;
6025                let mut optional_associated_source_id__ = None;
6026                while let Some(k) = map_.next_key()? {
6027                    match k {
6028                        GeneratedField::Id => {
6029                            if id__.is_some() {
6030                                return Err(serde::de::Error::duplicate_field("id"));
6031                            }
6032                            id__ = 
6033                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6034                            ;
6035                        }
6036                        GeneratedField::SchemaId => {
6037                            if schema_id__.is_some() {
6038                                return Err(serde::de::Error::duplicate_field("schemaId"));
6039                            }
6040                            schema_id__ = 
6041                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6042                            ;
6043                        }
6044                        GeneratedField::DatabaseId => {
6045                            if database_id__.is_some() {
6046                                return Err(serde::de::Error::duplicate_field("databaseId"));
6047                            }
6048                            database_id__ = 
6049                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6050                            ;
6051                        }
6052                        GeneratedField::Name => {
6053                            if name__.is_some() {
6054                                return Err(serde::de::Error::duplicate_field("name"));
6055                            }
6056                            name__ = Some(map_.next_value()?);
6057                        }
6058                        GeneratedField::Columns => {
6059                            if columns__.is_some() {
6060                                return Err(serde::de::Error::duplicate_field("columns"));
6061                            }
6062                            columns__ = Some(map_.next_value()?);
6063                        }
6064                        GeneratedField::Pk => {
6065                            if pk__.is_some() {
6066                                return Err(serde::de::Error::duplicate_field("pk"));
6067                            }
6068                            pk__ = Some(map_.next_value()?);
6069                        }
6070                        GeneratedField::TableType => {
6071                            if table_type__.is_some() {
6072                                return Err(serde::de::Error::duplicate_field("tableType"));
6073                            }
6074                            table_type__ = Some(map_.next_value::<table::TableType>()? as i32);
6075                        }
6076                        GeneratedField::DistributionKey => {
6077                            if distribution_key__.is_some() {
6078                                return Err(serde::de::Error::duplicate_field("distributionKey"));
6079                            }
6080                            distribution_key__ = 
6081                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6082                                    .into_iter().map(|x| x.0).collect())
6083                            ;
6084                        }
6085                        GeneratedField::StreamKey => {
6086                            if stream_key__.is_some() {
6087                                return Err(serde::de::Error::duplicate_field("streamKey"));
6088                            }
6089                            stream_key__ = 
6090                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6091                                    .into_iter().map(|x| x.0).collect())
6092                            ;
6093                        }
6094                        GeneratedField::AppendOnly => {
6095                            if append_only__.is_some() {
6096                                return Err(serde::de::Error::duplicate_field("appendOnly"));
6097                            }
6098                            append_only__ = Some(map_.next_value()?);
6099                        }
6100                        GeneratedField::Owner => {
6101                            if owner__.is_some() {
6102                                return Err(serde::de::Error::duplicate_field("owner"));
6103                            }
6104                            owner__ = 
6105                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6106                            ;
6107                        }
6108                        GeneratedField::FragmentId => {
6109                            if fragment_id__.is_some() {
6110                                return Err(serde::de::Error::duplicate_field("fragmentId"));
6111                            }
6112                            fragment_id__ = 
6113                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6114                            ;
6115                        }
6116                        GeneratedField::VnodeColIndex => {
6117                            if vnode_col_index__.is_some() {
6118                                return Err(serde::de::Error::duplicate_field("vnodeColIndex"));
6119                            }
6120                            vnode_col_index__ = 
6121                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6122                            ;
6123                        }
6124                        GeneratedField::RowIdIndex => {
6125                            if row_id_index__.is_some() {
6126                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
6127                            }
6128                            row_id_index__ = 
6129                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6130                            ;
6131                        }
6132                        GeneratedField::ValueIndices => {
6133                            if value_indices__.is_some() {
6134                                return Err(serde::de::Error::duplicate_field("valueIndices"));
6135                            }
6136                            value_indices__ = 
6137                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6138                                    .into_iter().map(|x| x.0).collect())
6139                            ;
6140                        }
6141                        GeneratedField::Definition => {
6142                            if definition__.is_some() {
6143                                return Err(serde::de::Error::duplicate_field("definition"));
6144                            }
6145                            definition__ = Some(map_.next_value()?);
6146                        }
6147                        GeneratedField::HandlePkConflictBehavior => {
6148                            if handle_pk_conflict_behavior__.is_some() {
6149                                return Err(serde::de::Error::duplicate_field("handlePkConflictBehavior"));
6150                            }
6151                            handle_pk_conflict_behavior__ = Some(map_.next_value::<HandleConflictBehavior>()? as i32);
6152                        }
6153                        GeneratedField::ReadPrefixLenHint => {
6154                            if read_prefix_len_hint__.is_some() {
6155                                return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
6156                            }
6157                            read_prefix_len_hint__ = 
6158                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6159                            ;
6160                        }
6161                        GeneratedField::WatermarkIndices => {
6162                            if watermark_indices__.is_some() {
6163                                return Err(serde::de::Error::duplicate_field("watermarkIndices"));
6164                            }
6165                            watermark_indices__ = 
6166                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6167                                    .into_iter().map(|x| x.0).collect())
6168                            ;
6169                        }
6170                        GeneratedField::DistKeyInPk => {
6171                            if dist_key_in_pk__.is_some() {
6172                                return Err(serde::de::Error::duplicate_field("distKeyInPk"));
6173                            }
6174                            dist_key_in_pk__ = 
6175                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6176                                    .into_iter().map(|x| x.0).collect())
6177                            ;
6178                        }
6179                        GeneratedField::DmlFragmentId => {
6180                            if dml_fragment_id__.is_some() {
6181                                return Err(serde::de::Error::duplicate_field("dmlFragmentId"));
6182                            }
6183                            dml_fragment_id__ = 
6184                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6185                            ;
6186                        }
6187                        GeneratedField::Cardinality => {
6188                            if cardinality__.is_some() {
6189                                return Err(serde::de::Error::duplicate_field("cardinality"));
6190                            }
6191                            cardinality__ = map_.next_value()?;
6192                        }
6193                        GeneratedField::InitializedAtEpoch => {
6194                            if initialized_at_epoch__.is_some() {
6195                                return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
6196                            }
6197                            initialized_at_epoch__ = 
6198                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6199                            ;
6200                        }
6201                        GeneratedField::CreatedAtEpoch => {
6202                            if created_at_epoch__.is_some() {
6203                                return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
6204                            }
6205                            created_at_epoch__ = 
6206                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6207                            ;
6208                        }
6209                        GeneratedField::CleanedByWatermark => {
6210                            if cleaned_by_watermark__.is_some() {
6211                                return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
6212                            }
6213                            cleaned_by_watermark__ = Some(map_.next_value()?);
6214                        }
6215                        GeneratedField::StreamJobStatus => {
6216                            if stream_job_status__.is_some() {
6217                                return Err(serde::de::Error::duplicate_field("streamJobStatus"));
6218                            }
6219                            stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
6220                        }
6221                        GeneratedField::CreateType => {
6222                            if create_type__.is_some() {
6223                                return Err(serde::de::Error::duplicate_field("createType"));
6224                            }
6225                            create_type__ = Some(map_.next_value::<CreateType>()? as i32);
6226                        }
6227                        GeneratedField::Description => {
6228                            if description__.is_some() {
6229                                return Err(serde::de::Error::duplicate_field("description"));
6230                            }
6231                            description__ = map_.next_value()?;
6232                        }
6233                        GeneratedField::IncomingSinks => {
6234                            if incoming_sinks__.is_some() {
6235                                return Err(serde::de::Error::duplicate_field("incomingSinks"));
6236                            }
6237                            incoming_sinks__ = 
6238                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6239                                    .into_iter().map(|x| x.0).collect())
6240                            ;
6241                        }
6242                        GeneratedField::InitializedAtClusterVersion => {
6243                            if initialized_at_cluster_version__.is_some() {
6244                                return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
6245                            }
6246                            initialized_at_cluster_version__ = map_.next_value()?;
6247                        }
6248                        GeneratedField::CreatedAtClusterVersion => {
6249                            if created_at_cluster_version__.is_some() {
6250                                return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
6251                            }
6252                            created_at_cluster_version__ = map_.next_value()?;
6253                        }
6254                        GeneratedField::RetentionSeconds => {
6255                            if retention_seconds__.is_some() {
6256                                return Err(serde::de::Error::duplicate_field("retentionSeconds"));
6257                            }
6258                            retention_seconds__ = 
6259                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6260                            ;
6261                        }
6262                        GeneratedField::VersionColumnIndices => {
6263                            if version_column_indices__.is_some() {
6264                                return Err(serde::de::Error::duplicate_field("versionColumnIndices"));
6265                            }
6266                            version_column_indices__ = 
6267                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6268                                    .into_iter().map(|x| x.0).collect())
6269                            ;
6270                        }
6271                        GeneratedField::CdcTableId => {
6272                            if cdc_table_id__.is_some() {
6273                                return Err(serde::de::Error::duplicate_field("cdcTableId"));
6274                            }
6275                            cdc_table_id__ = map_.next_value()?;
6276                        }
6277                        GeneratedField::MaybeVnodeCount => {
6278                            if maybe_vnode_count__.is_some() {
6279                                return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
6280                            }
6281                            maybe_vnode_count__ = 
6282                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6283                            ;
6284                        }
6285                        GeneratedField::WebhookInfo => {
6286                            if webhook_info__.is_some() {
6287                                return Err(serde::de::Error::duplicate_field("webhookInfo"));
6288                            }
6289                            webhook_info__ = map_.next_value()?;
6290                        }
6291                        GeneratedField::JobId => {
6292                            if job_id__.is_some() {
6293                                return Err(serde::de::Error::duplicate_field("jobId"));
6294                            }
6295                            job_id__ = 
6296                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6297                            ;
6298                        }
6299                        GeneratedField::Engine => {
6300                            if engine__.is_some() {
6301                                return Err(serde::de::Error::duplicate_field("engine"));
6302                            }
6303                            engine__ = map_.next_value::<::std::option::Option<table::Engine>>()?.map(|x| x as i32);
6304                        }
6305                        GeneratedField::CleanWatermarkIndexInPk => {
6306                            if clean_watermark_index_in_pk__.is_some() {
6307                                return Err(serde::de::Error::duplicate_field("cleanWatermarkIndexInPk"));
6308                            }
6309                            clean_watermark_index_in_pk__ = 
6310                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6311                            ;
6312                        }
6313                        GeneratedField::Refreshable => {
6314                            if refreshable__.is_some() {
6315                                return Err(serde::de::Error::duplicate_field("refreshable"));
6316                            }
6317                            refreshable__ = Some(map_.next_value()?);
6318                        }
6319                        GeneratedField::VectorIndexInfo => {
6320                            if vector_index_info__.is_some() {
6321                                return Err(serde::de::Error::duplicate_field("vectorIndexInfo"));
6322                            }
6323                            vector_index_info__ = map_.next_value()?;
6324                        }
6325                        GeneratedField::CdcTableType => {
6326                            if cdc_table_type__.is_some() {
6327                                return Err(serde::de::Error::duplicate_field("cdcTableType"));
6328                            }
6329                            cdc_table_type__ = map_.next_value::<::std::option::Option<table::CdcTableType>>()?.map(|x| x as i32);
6330                        }
6331                        GeneratedField::RefreshState => {
6332                            if refresh_state__.is_some() {
6333                                return Err(serde::de::Error::duplicate_field("refreshState"));
6334                            }
6335                            refresh_state__ = map_.next_value::<::std::option::Option<RefreshState>>()?.map(|x| x as i32);
6336                        }
6337                        GeneratedField::Version => {
6338                            if version__.is_some() {
6339                                return Err(serde::de::Error::duplicate_field("version"));
6340                            }
6341                            version__ = map_.next_value()?;
6342                        }
6343                        GeneratedField::AssociatedSourceId => {
6344                            if optional_associated_source_id__.is_some() {
6345                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6346                            }
6347                            optional_associated_source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| table::OptionalAssociatedSourceId::AssociatedSourceId(x.0));
6348                        }
6349                    }
6350                }
6351                Ok(Table {
6352                    id: id__.unwrap_or_default(),
6353                    schema_id: schema_id__.unwrap_or_default(),
6354                    database_id: database_id__.unwrap_or_default(),
6355                    name: name__.unwrap_or_default(),
6356                    columns: columns__.unwrap_or_default(),
6357                    pk: pk__.unwrap_or_default(),
6358                    table_type: table_type__.unwrap_or_default(),
6359                    distribution_key: distribution_key__.unwrap_or_default(),
6360                    stream_key: stream_key__.unwrap_or_default(),
6361                    append_only: append_only__.unwrap_or_default(),
6362                    owner: owner__.unwrap_or_default(),
6363                    fragment_id: fragment_id__.unwrap_or_default(),
6364                    vnode_col_index: vnode_col_index__,
6365                    row_id_index: row_id_index__,
6366                    value_indices: value_indices__.unwrap_or_default(),
6367                    definition: definition__.unwrap_or_default(),
6368                    handle_pk_conflict_behavior: handle_pk_conflict_behavior__.unwrap_or_default(),
6369                    read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
6370                    watermark_indices: watermark_indices__.unwrap_or_default(),
6371                    dist_key_in_pk: dist_key_in_pk__.unwrap_or_default(),
6372                    dml_fragment_id: dml_fragment_id__,
6373                    cardinality: cardinality__,
6374                    initialized_at_epoch: initialized_at_epoch__,
6375                    created_at_epoch: created_at_epoch__,
6376                    cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
6377                    stream_job_status: stream_job_status__.unwrap_or_default(),
6378                    create_type: create_type__.unwrap_or_default(),
6379                    description: description__,
6380                    incoming_sinks: incoming_sinks__.unwrap_or_default(),
6381                    initialized_at_cluster_version: initialized_at_cluster_version__,
6382                    created_at_cluster_version: created_at_cluster_version__,
6383                    retention_seconds: retention_seconds__,
6384                    version_column_indices: version_column_indices__.unwrap_or_default(),
6385                    cdc_table_id: cdc_table_id__,
6386                    maybe_vnode_count: maybe_vnode_count__,
6387                    webhook_info: webhook_info__,
6388                    job_id: job_id__,
6389                    engine: engine__,
6390                    clean_watermark_index_in_pk: clean_watermark_index_in_pk__,
6391                    refreshable: refreshable__.unwrap_or_default(),
6392                    vector_index_info: vector_index_info__,
6393                    cdc_table_type: cdc_table_type__,
6394                    refresh_state: refresh_state__,
6395                    version: version__,
6396                    optional_associated_source_id: optional_associated_source_id__,
6397                })
6398            }
6399        }
6400        deserializer.deserialize_struct("catalog.Table", FIELDS, GeneratedVisitor)
6401    }
6402}
6403impl serde::Serialize for table::CdcTableType {
6404    #[allow(deprecated)]
6405    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6406    where
6407        S: serde::Serializer,
6408    {
6409        let variant = match self {
6410            Self::Unspecified => "CDC_TABLE_TYPE_UNSPECIFIED",
6411            Self::Postgres => "CDC_TABLE_TYPE_POSTGRES",
6412            Self::Mysql => "CDC_TABLE_TYPE_MYSQL",
6413            Self::Sqlserver => "CDC_TABLE_TYPE_SQLSERVER",
6414            Self::Mongo => "CDC_TABLE_TYPE_MONGO",
6415            Self::Citus => "CDC_TABLE_TYPE_CITUS",
6416        };
6417        serializer.serialize_str(variant)
6418    }
6419}
6420impl<'de> serde::Deserialize<'de> for table::CdcTableType {
6421    #[allow(deprecated)]
6422    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6423    where
6424        D: serde::Deserializer<'de>,
6425    {
6426        const FIELDS: &[&str] = &[
6427            "CDC_TABLE_TYPE_UNSPECIFIED",
6428            "CDC_TABLE_TYPE_POSTGRES",
6429            "CDC_TABLE_TYPE_MYSQL",
6430            "CDC_TABLE_TYPE_SQLSERVER",
6431            "CDC_TABLE_TYPE_MONGO",
6432            "CDC_TABLE_TYPE_CITUS",
6433        ];
6434
6435        struct GeneratedVisitor;
6436
6437        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6438            type Value = table::CdcTableType;
6439
6440            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6441                write!(formatter, "expected one of: {:?}", &FIELDS)
6442            }
6443
6444            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6445            where
6446                E: serde::de::Error,
6447            {
6448                i32::try_from(v)
6449                    .ok()
6450                    .and_then(|x| x.try_into().ok())
6451                    .ok_or_else(|| {
6452                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6453                    })
6454            }
6455
6456            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6457            where
6458                E: serde::de::Error,
6459            {
6460                i32::try_from(v)
6461                    .ok()
6462                    .and_then(|x| x.try_into().ok())
6463                    .ok_or_else(|| {
6464                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6465                    })
6466            }
6467
6468            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6469            where
6470                E: serde::de::Error,
6471            {
6472                match value {
6473                    "CDC_TABLE_TYPE_UNSPECIFIED" => Ok(table::CdcTableType::Unspecified),
6474                    "CDC_TABLE_TYPE_POSTGRES" => Ok(table::CdcTableType::Postgres),
6475                    "CDC_TABLE_TYPE_MYSQL" => Ok(table::CdcTableType::Mysql),
6476                    "CDC_TABLE_TYPE_SQLSERVER" => Ok(table::CdcTableType::Sqlserver),
6477                    "CDC_TABLE_TYPE_MONGO" => Ok(table::CdcTableType::Mongo),
6478                    "CDC_TABLE_TYPE_CITUS" => Ok(table::CdcTableType::Citus),
6479                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6480                }
6481            }
6482        }
6483        deserializer.deserialize_any(GeneratedVisitor)
6484    }
6485}
6486impl serde::Serialize for table::Engine {
6487    #[allow(deprecated)]
6488    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6489    where
6490        S: serde::Serializer,
6491    {
6492        let variant = match self {
6493            Self::Unspecified => "ENGINE_UNSPECIFIED",
6494            Self::Hummock => "HUMMOCK",
6495            Self::Iceberg => "ICEBERG",
6496        };
6497        serializer.serialize_str(variant)
6498    }
6499}
6500impl<'de> serde::Deserialize<'de> for table::Engine {
6501    #[allow(deprecated)]
6502    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6503    where
6504        D: serde::Deserializer<'de>,
6505    {
6506        const FIELDS: &[&str] = &[
6507            "ENGINE_UNSPECIFIED",
6508            "HUMMOCK",
6509            "ICEBERG",
6510        ];
6511
6512        struct GeneratedVisitor;
6513
6514        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6515            type Value = table::Engine;
6516
6517            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6518                write!(formatter, "expected one of: {:?}", &FIELDS)
6519            }
6520
6521            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6522            where
6523                E: serde::de::Error,
6524            {
6525                i32::try_from(v)
6526                    .ok()
6527                    .and_then(|x| x.try_into().ok())
6528                    .ok_or_else(|| {
6529                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6530                    })
6531            }
6532
6533            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6534            where
6535                E: serde::de::Error,
6536            {
6537                i32::try_from(v)
6538                    .ok()
6539                    .and_then(|x| x.try_into().ok())
6540                    .ok_or_else(|| {
6541                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6542                    })
6543            }
6544
6545            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6546            where
6547                E: serde::de::Error,
6548            {
6549                match value {
6550                    "ENGINE_UNSPECIFIED" => Ok(table::Engine::Unspecified),
6551                    "HUMMOCK" => Ok(table::Engine::Hummock),
6552                    "ICEBERG" => Ok(table::Engine::Iceberg),
6553                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6554                }
6555            }
6556        }
6557        deserializer.deserialize_any(GeneratedVisitor)
6558    }
6559}
6560impl serde::Serialize for table::TableType {
6561    #[allow(deprecated)]
6562    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6563    where
6564        S: serde::Serializer,
6565    {
6566        let variant = match self {
6567            Self::Unspecified => "UNSPECIFIED",
6568            Self::Table => "TABLE",
6569            Self::MaterializedView => "MATERIALIZED_VIEW",
6570            Self::Index => "INDEX",
6571            Self::Internal => "INTERNAL",
6572            Self::VectorIndex => "VECTOR_INDEX",
6573        };
6574        serializer.serialize_str(variant)
6575    }
6576}
6577impl<'de> serde::Deserialize<'de> for table::TableType {
6578    #[allow(deprecated)]
6579    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6580    where
6581        D: serde::Deserializer<'de>,
6582    {
6583        const FIELDS: &[&str] = &[
6584            "UNSPECIFIED",
6585            "TABLE",
6586            "MATERIALIZED_VIEW",
6587            "INDEX",
6588            "INTERNAL",
6589            "VECTOR_INDEX",
6590        ];
6591
6592        struct GeneratedVisitor;
6593
6594        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6595            type Value = table::TableType;
6596
6597            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6598                write!(formatter, "expected one of: {:?}", &FIELDS)
6599            }
6600
6601            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6602            where
6603                E: serde::de::Error,
6604            {
6605                i32::try_from(v)
6606                    .ok()
6607                    .and_then(|x| x.try_into().ok())
6608                    .ok_or_else(|| {
6609                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6610                    })
6611            }
6612
6613            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6614            where
6615                E: serde::de::Error,
6616            {
6617                i32::try_from(v)
6618                    .ok()
6619                    .and_then(|x| x.try_into().ok())
6620                    .ok_or_else(|| {
6621                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6622                    })
6623            }
6624
6625            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6626            where
6627                E: serde::de::Error,
6628            {
6629                match value {
6630                    "UNSPECIFIED" => Ok(table::TableType::Unspecified),
6631                    "TABLE" => Ok(table::TableType::Table),
6632                    "MATERIALIZED_VIEW" => Ok(table::TableType::MaterializedView),
6633                    "INDEX" => Ok(table::TableType::Index),
6634                    "INTERNAL" => Ok(table::TableType::Internal),
6635                    "VECTOR_INDEX" => Ok(table::TableType::VectorIndex),
6636                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6637                }
6638            }
6639        }
6640        deserializer.deserialize_any(GeneratedVisitor)
6641    }
6642}
6643impl serde::Serialize for table::TableVersion {
6644    #[allow(deprecated)]
6645    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6646    where
6647        S: serde::Serializer,
6648    {
6649        use serde::ser::SerializeStruct;
6650        let mut len = 0;
6651        if self.version != 0 {
6652            len += 1;
6653        }
6654        if self.next_column_id != 0 {
6655            len += 1;
6656        }
6657        let mut struct_ser = serializer.serialize_struct("catalog.Table.TableVersion", len)?;
6658        if self.version != 0 {
6659            #[allow(clippy::needless_borrow)]
6660            #[allow(clippy::needless_borrows_for_generic_args)]
6661            struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
6662        }
6663        if self.next_column_id != 0 {
6664            struct_ser.serialize_field("nextColumnId", &self.next_column_id)?;
6665        }
6666        struct_ser.end()
6667    }
6668}
6669impl<'de> serde::Deserialize<'de> for table::TableVersion {
6670    #[allow(deprecated)]
6671    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6672    where
6673        D: serde::Deserializer<'de>,
6674    {
6675        const FIELDS: &[&str] = &[
6676            "version",
6677            "next_column_id",
6678            "nextColumnId",
6679        ];
6680
6681        #[allow(clippy::enum_variant_names)]
6682        enum GeneratedField {
6683            Version,
6684            NextColumnId,
6685        }
6686        impl<'de> serde::Deserialize<'de> for GeneratedField {
6687            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6688            where
6689                D: serde::Deserializer<'de>,
6690            {
6691                struct GeneratedVisitor;
6692
6693                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6694                    type Value = GeneratedField;
6695
6696                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6697                        write!(formatter, "expected one of: {:?}", &FIELDS)
6698                    }
6699
6700                    #[allow(unused_variables)]
6701                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6702                    where
6703                        E: serde::de::Error,
6704                    {
6705                        match value {
6706                            "version" => Ok(GeneratedField::Version),
6707                            "nextColumnId" | "next_column_id" => Ok(GeneratedField::NextColumnId),
6708                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6709                        }
6710                    }
6711                }
6712                deserializer.deserialize_identifier(GeneratedVisitor)
6713            }
6714        }
6715        struct GeneratedVisitor;
6716        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6717            type Value = table::TableVersion;
6718
6719            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6720                formatter.write_str("struct catalog.Table.TableVersion")
6721            }
6722
6723            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table::TableVersion, V::Error>
6724                where
6725                    V: serde::de::MapAccess<'de>,
6726            {
6727                let mut version__ = None;
6728                let mut next_column_id__ = None;
6729                while let Some(k) = map_.next_key()? {
6730                    match k {
6731                        GeneratedField::Version => {
6732                            if version__.is_some() {
6733                                return Err(serde::de::Error::duplicate_field("version"));
6734                            }
6735                            version__ = 
6736                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6737                            ;
6738                        }
6739                        GeneratedField::NextColumnId => {
6740                            if next_column_id__.is_some() {
6741                                return Err(serde::de::Error::duplicate_field("nextColumnId"));
6742                            }
6743                            next_column_id__ = 
6744                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6745                            ;
6746                        }
6747                    }
6748                }
6749                Ok(table::TableVersion {
6750                    version: version__.unwrap_or_default(),
6751                    next_column_id: next_column_id__.unwrap_or_default(),
6752                })
6753            }
6754        }
6755        deserializer.deserialize_struct("catalog.Table.TableVersion", FIELDS, GeneratedVisitor)
6756    }
6757}
6758impl serde::Serialize for VectorIndexInfo {
6759    #[allow(deprecated)]
6760    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6761    where
6762        S: serde::Serializer,
6763    {
6764        use serde::ser::SerializeStruct;
6765        let mut len = 0;
6766        if self.dimension != 0 {
6767            len += 1;
6768        }
6769        if self.distance_type != 0 {
6770            len += 1;
6771        }
6772        if self.config.is_some() {
6773            len += 1;
6774        }
6775        let mut struct_ser = serializer.serialize_struct("catalog.VectorIndexInfo", len)?;
6776        if self.dimension != 0 {
6777            struct_ser.serialize_field("dimension", &self.dimension)?;
6778        }
6779        if self.distance_type != 0 {
6780            let v = super::common::DistanceType::try_from(self.distance_type)
6781                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
6782            struct_ser.serialize_field("distanceType", &v)?;
6783        }
6784        if let Some(v) = self.config.as_ref() {
6785            match v {
6786                vector_index_info::Config::Flat(v) => {
6787                    struct_ser.serialize_field("flat", v)?;
6788                }
6789                vector_index_info::Config::HnswFlat(v) => {
6790                    struct_ser.serialize_field("hnswFlat", v)?;
6791                }
6792            }
6793        }
6794        struct_ser.end()
6795    }
6796}
6797impl<'de> serde::Deserialize<'de> for VectorIndexInfo {
6798    #[allow(deprecated)]
6799    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6800    where
6801        D: serde::Deserializer<'de>,
6802    {
6803        const FIELDS: &[&str] = &[
6804            "dimension",
6805            "distance_type",
6806            "distanceType",
6807            "flat",
6808            "hnsw_flat",
6809            "hnswFlat",
6810        ];
6811
6812        #[allow(clippy::enum_variant_names)]
6813        enum GeneratedField {
6814            Dimension,
6815            DistanceType,
6816            Flat,
6817            HnswFlat,
6818        }
6819        impl<'de> serde::Deserialize<'de> for GeneratedField {
6820            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6821            where
6822                D: serde::Deserializer<'de>,
6823            {
6824                struct GeneratedVisitor;
6825
6826                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6827                    type Value = GeneratedField;
6828
6829                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6830                        write!(formatter, "expected one of: {:?}", &FIELDS)
6831                    }
6832
6833                    #[allow(unused_variables)]
6834                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6835                    where
6836                        E: serde::de::Error,
6837                    {
6838                        match value {
6839                            "dimension" => Ok(GeneratedField::Dimension),
6840                            "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
6841                            "flat" => Ok(GeneratedField::Flat),
6842                            "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
6843                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6844                        }
6845                    }
6846                }
6847                deserializer.deserialize_identifier(GeneratedVisitor)
6848            }
6849        }
6850        struct GeneratedVisitor;
6851        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6852            type Value = VectorIndexInfo;
6853
6854            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6855                formatter.write_str("struct catalog.VectorIndexInfo")
6856            }
6857
6858            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexInfo, V::Error>
6859                where
6860                    V: serde::de::MapAccess<'de>,
6861            {
6862                let mut dimension__ = None;
6863                let mut distance_type__ = None;
6864                let mut config__ = None;
6865                while let Some(k) = map_.next_key()? {
6866                    match k {
6867                        GeneratedField::Dimension => {
6868                            if dimension__.is_some() {
6869                                return Err(serde::de::Error::duplicate_field("dimension"));
6870                            }
6871                            dimension__ = 
6872                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6873                            ;
6874                        }
6875                        GeneratedField::DistanceType => {
6876                            if distance_type__.is_some() {
6877                                return Err(serde::de::Error::duplicate_field("distanceType"));
6878                            }
6879                            distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
6880                        }
6881                        GeneratedField::Flat => {
6882                            if config__.is_some() {
6883                                return Err(serde::de::Error::duplicate_field("flat"));
6884                            }
6885                            config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::Flat)
6886;
6887                        }
6888                        GeneratedField::HnswFlat => {
6889                            if config__.is_some() {
6890                                return Err(serde::de::Error::duplicate_field("hnswFlat"));
6891                            }
6892                            config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::HnswFlat)
6893;
6894                        }
6895                    }
6896                }
6897                Ok(VectorIndexInfo {
6898                    dimension: dimension__.unwrap_or_default(),
6899                    distance_type: distance_type__.unwrap_or_default(),
6900                    config: config__,
6901                })
6902            }
6903        }
6904        deserializer.deserialize_struct("catalog.VectorIndexInfo", FIELDS, GeneratedVisitor)
6905    }
6906}
6907impl serde::Serialize for View {
6908    #[allow(deprecated)]
6909    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6910    where
6911        S: serde::Serializer,
6912    {
6913        use serde::ser::SerializeStruct;
6914        let mut len = 0;
6915        if self.id != 0 {
6916            len += 1;
6917        }
6918        if self.schema_id != 0 {
6919            len += 1;
6920        }
6921        if self.database_id != 0 {
6922            len += 1;
6923        }
6924        if !self.name.is_empty() {
6925            len += 1;
6926        }
6927        if self.owner != 0 {
6928            len += 1;
6929        }
6930        if !self.properties.is_empty() {
6931            len += 1;
6932        }
6933        if !self.sql.is_empty() {
6934            len += 1;
6935        }
6936        if !self.columns.is_empty() {
6937            len += 1;
6938        }
6939        let mut struct_ser = serializer.serialize_struct("catalog.View", len)?;
6940        if self.id != 0 {
6941            struct_ser.serialize_field("id", &self.id)?;
6942        }
6943        if self.schema_id != 0 {
6944            struct_ser.serialize_field("schemaId", &self.schema_id)?;
6945        }
6946        if self.database_id != 0 {
6947            struct_ser.serialize_field("databaseId", &self.database_id)?;
6948        }
6949        if !self.name.is_empty() {
6950            struct_ser.serialize_field("name", &self.name)?;
6951        }
6952        if self.owner != 0 {
6953            struct_ser.serialize_field("owner", &self.owner)?;
6954        }
6955        if !self.properties.is_empty() {
6956            struct_ser.serialize_field("properties", &self.properties)?;
6957        }
6958        if !self.sql.is_empty() {
6959            struct_ser.serialize_field("sql", &self.sql)?;
6960        }
6961        if !self.columns.is_empty() {
6962            struct_ser.serialize_field("columns", &self.columns)?;
6963        }
6964        struct_ser.end()
6965    }
6966}
6967impl<'de> serde::Deserialize<'de> for View {
6968    #[allow(deprecated)]
6969    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6970    where
6971        D: serde::Deserializer<'de>,
6972    {
6973        const FIELDS: &[&str] = &[
6974            "id",
6975            "schema_id",
6976            "schemaId",
6977            "database_id",
6978            "databaseId",
6979            "name",
6980            "owner",
6981            "properties",
6982            "sql",
6983            "columns",
6984        ];
6985
6986        #[allow(clippy::enum_variant_names)]
6987        enum GeneratedField {
6988            Id,
6989            SchemaId,
6990            DatabaseId,
6991            Name,
6992            Owner,
6993            Properties,
6994            Sql,
6995            Columns,
6996        }
6997        impl<'de> serde::Deserialize<'de> for GeneratedField {
6998            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6999            where
7000                D: serde::Deserializer<'de>,
7001            {
7002                struct GeneratedVisitor;
7003
7004                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7005                    type Value = GeneratedField;
7006
7007                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7008                        write!(formatter, "expected one of: {:?}", &FIELDS)
7009                    }
7010
7011                    #[allow(unused_variables)]
7012                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7013                    where
7014                        E: serde::de::Error,
7015                    {
7016                        match value {
7017                            "id" => Ok(GeneratedField::Id),
7018                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
7019                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
7020                            "name" => Ok(GeneratedField::Name),
7021                            "owner" => Ok(GeneratedField::Owner),
7022                            "properties" => Ok(GeneratedField::Properties),
7023                            "sql" => Ok(GeneratedField::Sql),
7024                            "columns" => Ok(GeneratedField::Columns),
7025                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7026                        }
7027                    }
7028                }
7029                deserializer.deserialize_identifier(GeneratedVisitor)
7030            }
7031        }
7032        struct GeneratedVisitor;
7033        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7034            type Value = View;
7035
7036            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7037                formatter.write_str("struct catalog.View")
7038            }
7039
7040            fn visit_map<V>(self, mut map_: V) -> std::result::Result<View, V::Error>
7041                where
7042                    V: serde::de::MapAccess<'de>,
7043            {
7044                let mut id__ = None;
7045                let mut schema_id__ = None;
7046                let mut database_id__ = None;
7047                let mut name__ = None;
7048                let mut owner__ = None;
7049                let mut properties__ = None;
7050                let mut sql__ = None;
7051                let mut columns__ = None;
7052                while let Some(k) = map_.next_key()? {
7053                    match k {
7054                        GeneratedField::Id => {
7055                            if id__.is_some() {
7056                                return Err(serde::de::Error::duplicate_field("id"));
7057                            }
7058                            id__ = 
7059                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7060                            ;
7061                        }
7062                        GeneratedField::SchemaId => {
7063                            if schema_id__.is_some() {
7064                                return Err(serde::de::Error::duplicate_field("schemaId"));
7065                            }
7066                            schema_id__ = 
7067                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7068                            ;
7069                        }
7070                        GeneratedField::DatabaseId => {
7071                            if database_id__.is_some() {
7072                                return Err(serde::de::Error::duplicate_field("databaseId"));
7073                            }
7074                            database_id__ = 
7075                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7076                            ;
7077                        }
7078                        GeneratedField::Name => {
7079                            if name__.is_some() {
7080                                return Err(serde::de::Error::duplicate_field("name"));
7081                            }
7082                            name__ = Some(map_.next_value()?);
7083                        }
7084                        GeneratedField::Owner => {
7085                            if owner__.is_some() {
7086                                return Err(serde::de::Error::duplicate_field("owner"));
7087                            }
7088                            owner__ = 
7089                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7090                            ;
7091                        }
7092                        GeneratedField::Properties => {
7093                            if properties__.is_some() {
7094                                return Err(serde::de::Error::duplicate_field("properties"));
7095                            }
7096                            properties__ = Some(
7097                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
7098                            );
7099                        }
7100                        GeneratedField::Sql => {
7101                            if sql__.is_some() {
7102                                return Err(serde::de::Error::duplicate_field("sql"));
7103                            }
7104                            sql__ = Some(map_.next_value()?);
7105                        }
7106                        GeneratedField::Columns => {
7107                            if columns__.is_some() {
7108                                return Err(serde::de::Error::duplicate_field("columns"));
7109                            }
7110                            columns__ = Some(map_.next_value()?);
7111                        }
7112                    }
7113                }
7114                Ok(View {
7115                    id: id__.unwrap_or_default(),
7116                    schema_id: schema_id__.unwrap_or_default(),
7117                    database_id: database_id__.unwrap_or_default(),
7118                    name: name__.unwrap_or_default(),
7119                    owner: owner__.unwrap_or_default(),
7120                    properties: properties__.unwrap_or_default(),
7121                    sql: sql__.unwrap_or_default(),
7122                    columns: columns__.unwrap_or_default(),
7123                })
7124            }
7125        }
7126        deserializer.deserialize_struct("catalog.View", FIELDS, GeneratedVisitor)
7127    }
7128}
7129impl serde::Serialize for WatermarkDesc {
7130    #[allow(deprecated)]
7131    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7132    where
7133        S: serde::Serializer,
7134    {
7135        use serde::ser::SerializeStruct;
7136        let mut len = 0;
7137        if self.watermark_idx != 0 {
7138            len += 1;
7139        }
7140        if self.expr.is_some() {
7141            len += 1;
7142        }
7143        let mut struct_ser = serializer.serialize_struct("catalog.WatermarkDesc", len)?;
7144        if self.watermark_idx != 0 {
7145            struct_ser.serialize_field("watermarkIdx", &self.watermark_idx)?;
7146        }
7147        if let Some(v) = self.expr.as_ref() {
7148            struct_ser.serialize_field("expr", v)?;
7149        }
7150        struct_ser.end()
7151    }
7152}
7153impl<'de> serde::Deserialize<'de> for WatermarkDesc {
7154    #[allow(deprecated)]
7155    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7156    where
7157        D: serde::Deserializer<'de>,
7158    {
7159        const FIELDS: &[&str] = &[
7160            "watermark_idx",
7161            "watermarkIdx",
7162            "expr",
7163        ];
7164
7165        #[allow(clippy::enum_variant_names)]
7166        enum GeneratedField {
7167            WatermarkIdx,
7168            Expr,
7169        }
7170        impl<'de> serde::Deserialize<'de> for GeneratedField {
7171            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7172            where
7173                D: serde::Deserializer<'de>,
7174            {
7175                struct GeneratedVisitor;
7176
7177                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7178                    type Value = GeneratedField;
7179
7180                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7181                        write!(formatter, "expected one of: {:?}", &FIELDS)
7182                    }
7183
7184                    #[allow(unused_variables)]
7185                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7186                    where
7187                        E: serde::de::Error,
7188                    {
7189                        match value {
7190                            "watermarkIdx" | "watermark_idx" => Ok(GeneratedField::WatermarkIdx),
7191                            "expr" => Ok(GeneratedField::Expr),
7192                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7193                        }
7194                    }
7195                }
7196                deserializer.deserialize_identifier(GeneratedVisitor)
7197            }
7198        }
7199        struct GeneratedVisitor;
7200        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7201            type Value = WatermarkDesc;
7202
7203            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7204                formatter.write_str("struct catalog.WatermarkDesc")
7205            }
7206
7207            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkDesc, V::Error>
7208                where
7209                    V: serde::de::MapAccess<'de>,
7210            {
7211                let mut watermark_idx__ = None;
7212                let mut expr__ = None;
7213                while let Some(k) = map_.next_key()? {
7214                    match k {
7215                        GeneratedField::WatermarkIdx => {
7216                            if watermark_idx__.is_some() {
7217                                return Err(serde::de::Error::duplicate_field("watermarkIdx"));
7218                            }
7219                            watermark_idx__ = 
7220                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7221                            ;
7222                        }
7223                        GeneratedField::Expr => {
7224                            if expr__.is_some() {
7225                                return Err(serde::de::Error::duplicate_field("expr"));
7226                            }
7227                            expr__ = map_.next_value()?;
7228                        }
7229                    }
7230                }
7231                Ok(WatermarkDesc {
7232                    watermark_idx: watermark_idx__.unwrap_or_default(),
7233                    expr: expr__,
7234                })
7235            }
7236        }
7237        deserializer.deserialize_struct("catalog.WatermarkDesc", FIELDS, GeneratedVisitor)
7238    }
7239}
7240impl serde::Serialize for WebhookSourceInfo {
7241    #[allow(deprecated)]
7242    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7243    where
7244        S: serde::Serializer,
7245    {
7246        use serde::ser::SerializeStruct;
7247        let mut len = 0;
7248        if self.secret_ref.is_some() {
7249            len += 1;
7250        }
7251        if self.signature_expr.is_some() {
7252            len += 1;
7253        }
7254        if self.wait_for_persistence {
7255            len += 1;
7256        }
7257        if self.is_batched {
7258            len += 1;
7259        }
7260        let mut struct_ser = serializer.serialize_struct("catalog.WebhookSourceInfo", len)?;
7261        if let Some(v) = self.secret_ref.as_ref() {
7262            struct_ser.serialize_field("secretRef", v)?;
7263        }
7264        if let Some(v) = self.signature_expr.as_ref() {
7265            struct_ser.serialize_field("signatureExpr", v)?;
7266        }
7267        if self.wait_for_persistence {
7268            struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
7269        }
7270        if self.is_batched {
7271            struct_ser.serialize_field("isBatched", &self.is_batched)?;
7272        }
7273        struct_ser.end()
7274    }
7275}
7276impl<'de> serde::Deserialize<'de> for WebhookSourceInfo {
7277    #[allow(deprecated)]
7278    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7279    where
7280        D: serde::Deserializer<'de>,
7281    {
7282        const FIELDS: &[&str] = &[
7283            "secret_ref",
7284            "secretRef",
7285            "signature_expr",
7286            "signatureExpr",
7287            "wait_for_persistence",
7288            "waitForPersistence",
7289            "is_batched",
7290            "isBatched",
7291        ];
7292
7293        #[allow(clippy::enum_variant_names)]
7294        enum GeneratedField {
7295            SecretRef,
7296            SignatureExpr,
7297            WaitForPersistence,
7298            IsBatched,
7299        }
7300        impl<'de> serde::Deserialize<'de> for GeneratedField {
7301            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7302            where
7303                D: serde::Deserializer<'de>,
7304            {
7305                struct GeneratedVisitor;
7306
7307                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7308                    type Value = GeneratedField;
7309
7310                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7311                        write!(formatter, "expected one of: {:?}", &FIELDS)
7312                    }
7313
7314                    #[allow(unused_variables)]
7315                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7316                    where
7317                        E: serde::de::Error,
7318                    {
7319                        match value {
7320                            "secretRef" | "secret_ref" => Ok(GeneratedField::SecretRef),
7321                            "signatureExpr" | "signature_expr" => Ok(GeneratedField::SignatureExpr),
7322                            "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
7323                            "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
7324                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7325                        }
7326                    }
7327                }
7328                deserializer.deserialize_identifier(GeneratedVisitor)
7329            }
7330        }
7331        struct GeneratedVisitor;
7332        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7333            type Value = WebhookSourceInfo;
7334
7335            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7336                formatter.write_str("struct catalog.WebhookSourceInfo")
7337            }
7338
7339            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WebhookSourceInfo, V::Error>
7340                where
7341                    V: serde::de::MapAccess<'de>,
7342            {
7343                let mut secret_ref__ = None;
7344                let mut signature_expr__ = None;
7345                let mut wait_for_persistence__ = None;
7346                let mut is_batched__ = None;
7347                while let Some(k) = map_.next_key()? {
7348                    match k {
7349                        GeneratedField::SecretRef => {
7350                            if secret_ref__.is_some() {
7351                                return Err(serde::de::Error::duplicate_field("secretRef"));
7352                            }
7353                            secret_ref__ = map_.next_value()?;
7354                        }
7355                        GeneratedField::SignatureExpr => {
7356                            if signature_expr__.is_some() {
7357                                return Err(serde::de::Error::duplicate_field("signatureExpr"));
7358                            }
7359                            signature_expr__ = map_.next_value()?;
7360                        }
7361                        GeneratedField::WaitForPersistence => {
7362                            if wait_for_persistence__.is_some() {
7363                                return Err(serde::de::Error::duplicate_field("waitForPersistence"));
7364                            }
7365                            wait_for_persistence__ = Some(map_.next_value()?);
7366                        }
7367                        GeneratedField::IsBatched => {
7368                            if is_batched__.is_some() {
7369                                return Err(serde::de::Error::duplicate_field("isBatched"));
7370                            }
7371                            is_batched__ = Some(map_.next_value()?);
7372                        }
7373                    }
7374                }
7375                Ok(WebhookSourceInfo {
7376                    secret_ref: secret_ref__,
7377                    signature_expr: signature_expr__,
7378                    wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
7379                    is_batched: is_batched__.unwrap_or_default(),
7380                })
7381            }
7382        }
7383        deserializer.deserialize_struct("catalog.WebhookSourceInfo", FIELDS, GeneratedVisitor)
7384    }
7385}