risingwave_pb/
catalog.serde.rs

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