Skip to main content

risingwave_pb/
catalog.serde.rs

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