1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::user::*;
4impl serde::Serialize for Action {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 let variant = match self {
11 Self::Unspecified => "UNSPECIFIED",
12 Self::Select => "SELECT",
13 Self::Insert => "INSERT",
14 Self::Update => "UPDATE",
15 Self::Delete => "DELETE",
16 Self::Create => "CREATE",
17 Self::Connect => "CONNECT",
18 Self::Usage => "USAGE",
19 Self::Execute => "EXECUTE",
20 };
21 serializer.serialize_str(variant)
22 }
23}
24impl<'de> serde::Deserialize<'de> for Action {
25 #[allow(deprecated)]
26 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
27 where
28 D: serde::Deserializer<'de>,
29 {
30 const FIELDS: &[&str] = &[
31 "UNSPECIFIED",
32 "SELECT",
33 "INSERT",
34 "UPDATE",
35 "DELETE",
36 "CREATE",
37 "CONNECT",
38 "USAGE",
39 "EXECUTE",
40 ];
41
42 struct GeneratedVisitor;
43
44 impl serde::de::Visitor<'_> for GeneratedVisitor {
45 type Value = Action;
46
47 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 write!(formatter, "expected one of: {:?}", &FIELDS)
49 }
50
51 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
52 where
53 E: serde::de::Error,
54 {
55 i32::try_from(v)
56 .ok()
57 .and_then(|x| x.try_into().ok())
58 .ok_or_else(|| {
59 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
60 })
61 }
62
63 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
64 where
65 E: serde::de::Error,
66 {
67 i32::try_from(v)
68 .ok()
69 .and_then(|x| x.try_into().ok())
70 .ok_or_else(|| {
71 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
72 })
73 }
74
75 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
76 where
77 E: serde::de::Error,
78 {
79 match value {
80 "UNSPECIFIED" => Ok(Action::Unspecified),
81 "SELECT" => Ok(Action::Select),
82 "INSERT" => Ok(Action::Insert),
83 "UPDATE" => Ok(Action::Update),
84 "DELETE" => Ok(Action::Delete),
85 "CREATE" => Ok(Action::Create),
86 "CONNECT" => Ok(Action::Connect),
87 "USAGE" => Ok(Action::Usage),
88 "EXECUTE" => Ok(Action::Execute),
89 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
90 }
91 }
92 }
93 deserializer.deserialize_any(GeneratedVisitor)
94 }
95}
96impl serde::Serialize for AlterDefaultPrivilegeRequest {
97 #[allow(deprecated)]
98 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
99 where
100 S: serde::Serializer,
101 {
102 use serde::ser::SerializeStruct;
103 let mut len = 0;
104 if !self.user_ids.is_empty() {
105 len += 1;
106 }
107 if self.database_id != 0 {
108 len += 1;
109 }
110 if !self.schema_ids.is_empty() {
111 len += 1;
112 }
113 if self.granted_by != 0 {
114 len += 1;
115 }
116 if self.operation.is_some() {
117 len += 1;
118 }
119 let mut struct_ser = serializer.serialize_struct("user.AlterDefaultPrivilegeRequest", len)?;
120 if !self.user_ids.is_empty() {
121 struct_ser.serialize_field("userIds", &self.user_ids)?;
122 }
123 if self.database_id != 0 {
124 struct_ser.serialize_field("databaseId", &self.database_id)?;
125 }
126 if !self.schema_ids.is_empty() {
127 struct_ser.serialize_field("schemaIds", &self.schema_ids)?;
128 }
129 if self.granted_by != 0 {
130 struct_ser.serialize_field("grantedBy", &self.granted_by)?;
131 }
132 if let Some(v) = self.operation.as_ref() {
133 match v {
134 alter_default_privilege_request::Operation::GrantPrivilege(v) => {
135 struct_ser.serialize_field("grantPrivilege", v)?;
136 }
137 alter_default_privilege_request::Operation::RevokePrivilege(v) => {
138 struct_ser.serialize_field("revokePrivilege", v)?;
139 }
140 }
141 }
142 struct_ser.end()
143 }
144}
145impl<'de> serde::Deserialize<'de> for AlterDefaultPrivilegeRequest {
146 #[allow(deprecated)]
147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
148 where
149 D: serde::Deserializer<'de>,
150 {
151 const FIELDS: &[&str] = &[
152 "user_ids",
153 "userIds",
154 "database_id",
155 "databaseId",
156 "schema_ids",
157 "schemaIds",
158 "granted_by",
159 "grantedBy",
160 "grant_privilege",
161 "grantPrivilege",
162 "revoke_privilege",
163 "revokePrivilege",
164 ];
165
166 #[allow(clippy::enum_variant_names)]
167 enum GeneratedField {
168 UserIds,
169 DatabaseId,
170 SchemaIds,
171 GrantedBy,
172 GrantPrivilege,
173 RevokePrivilege,
174 }
175 impl<'de> serde::Deserialize<'de> for GeneratedField {
176 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
177 where
178 D: serde::Deserializer<'de>,
179 {
180 struct GeneratedVisitor;
181
182 impl serde::de::Visitor<'_> for GeneratedVisitor {
183 type Value = GeneratedField;
184
185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
186 write!(formatter, "expected one of: {:?}", &FIELDS)
187 }
188
189 #[allow(unused_variables)]
190 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
191 where
192 E: serde::de::Error,
193 {
194 match value {
195 "userIds" | "user_ids" => Ok(GeneratedField::UserIds),
196 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
197 "schemaIds" | "schema_ids" => Ok(GeneratedField::SchemaIds),
198 "grantedBy" | "granted_by" => Ok(GeneratedField::GrantedBy),
199 "grantPrivilege" | "grant_privilege" => Ok(GeneratedField::GrantPrivilege),
200 "revokePrivilege" | "revoke_privilege" => Ok(GeneratedField::RevokePrivilege),
201 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
202 }
203 }
204 }
205 deserializer.deserialize_identifier(GeneratedVisitor)
206 }
207 }
208 struct GeneratedVisitor;
209 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
210 type Value = AlterDefaultPrivilegeRequest;
211
212 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
213 formatter.write_str("struct user.AlterDefaultPrivilegeRequest")
214 }
215
216 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDefaultPrivilegeRequest, V::Error>
217 where
218 V: serde::de::MapAccess<'de>,
219 {
220 let mut user_ids__ = None;
221 let mut database_id__ = None;
222 let mut schema_ids__ = None;
223 let mut granted_by__ = None;
224 let mut operation__ = None;
225 while let Some(k) = map_.next_key()? {
226 match k {
227 GeneratedField::UserIds => {
228 if user_ids__.is_some() {
229 return Err(serde::de::Error::duplicate_field("userIds"));
230 }
231 user_ids__ =
232 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
233 .into_iter().map(|x| x.0).collect())
234 ;
235 }
236 GeneratedField::DatabaseId => {
237 if database_id__.is_some() {
238 return Err(serde::de::Error::duplicate_field("databaseId"));
239 }
240 database_id__ =
241 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
242 ;
243 }
244 GeneratedField::SchemaIds => {
245 if schema_ids__.is_some() {
246 return Err(serde::de::Error::duplicate_field("schemaIds"));
247 }
248 schema_ids__ =
249 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
250 .into_iter().map(|x| x.0).collect())
251 ;
252 }
253 GeneratedField::GrantedBy => {
254 if granted_by__.is_some() {
255 return Err(serde::de::Error::duplicate_field("grantedBy"));
256 }
257 granted_by__ =
258 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
259 ;
260 }
261 GeneratedField::GrantPrivilege => {
262 if operation__.is_some() {
263 return Err(serde::de::Error::duplicate_field("grantPrivilege"));
264 }
265 operation__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_default_privilege_request::Operation::GrantPrivilege)
266;
267 }
268 GeneratedField::RevokePrivilege => {
269 if operation__.is_some() {
270 return Err(serde::de::Error::duplicate_field("revokePrivilege"));
271 }
272 operation__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_default_privilege_request::Operation::RevokePrivilege)
273;
274 }
275 }
276 }
277 Ok(AlterDefaultPrivilegeRequest {
278 user_ids: user_ids__.unwrap_or_default(),
279 database_id: database_id__.unwrap_or_default(),
280 schema_ids: schema_ids__.unwrap_or_default(),
281 granted_by: granted_by__.unwrap_or_default(),
282 operation: operation__,
283 })
284 }
285 }
286 deserializer.deserialize_struct("user.AlterDefaultPrivilegeRequest", FIELDS, GeneratedVisitor)
287 }
288}
289impl serde::Serialize for alter_default_privilege_request::GrantPrivilege {
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.actions.is_empty() {
298 len += 1;
299 }
300 if self.object_type != 0 {
301 len += 1;
302 }
303 if !self.grantees.is_empty() {
304 len += 1;
305 }
306 if self.with_grant_option {
307 len += 1;
308 }
309 let mut struct_ser = serializer.serialize_struct("user.AlterDefaultPrivilegeRequest.GrantPrivilege", len)?;
310 if !self.actions.is_empty() {
311 let v = self.actions.iter().cloned().map(|v| {
312 Action::try_from(v)
313 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
314 }).collect::<std::result::Result<Vec<_>, _>>()?;
315 struct_ser.serialize_field("actions", &v)?;
316 }
317 if self.object_type != 0 {
318 let v = super::common::ObjectType::try_from(self.object_type)
319 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
320 struct_ser.serialize_field("objectType", &v)?;
321 }
322 if !self.grantees.is_empty() {
323 struct_ser.serialize_field("grantees", &self.grantees)?;
324 }
325 if self.with_grant_option {
326 struct_ser.serialize_field("withGrantOption", &self.with_grant_option)?;
327 }
328 struct_ser.end()
329 }
330}
331impl<'de> serde::Deserialize<'de> for alter_default_privilege_request::GrantPrivilege {
332 #[allow(deprecated)]
333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
334 where
335 D: serde::Deserializer<'de>,
336 {
337 const FIELDS: &[&str] = &[
338 "actions",
339 "object_type",
340 "objectType",
341 "grantees",
342 "with_grant_option",
343 "withGrantOption",
344 ];
345
346 #[allow(clippy::enum_variant_names)]
347 enum GeneratedField {
348 Actions,
349 ObjectType,
350 Grantees,
351 WithGrantOption,
352 }
353 impl<'de> serde::Deserialize<'de> for GeneratedField {
354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
355 where
356 D: serde::Deserializer<'de>,
357 {
358 struct GeneratedVisitor;
359
360 impl serde::de::Visitor<'_> for GeneratedVisitor {
361 type Value = GeneratedField;
362
363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
364 write!(formatter, "expected one of: {:?}", &FIELDS)
365 }
366
367 #[allow(unused_variables)]
368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
369 where
370 E: serde::de::Error,
371 {
372 match value {
373 "actions" => Ok(GeneratedField::Actions),
374 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
375 "grantees" => Ok(GeneratedField::Grantees),
376 "withGrantOption" | "with_grant_option" => Ok(GeneratedField::WithGrantOption),
377 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
378 }
379 }
380 }
381 deserializer.deserialize_identifier(GeneratedVisitor)
382 }
383 }
384 struct GeneratedVisitor;
385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
386 type Value = alter_default_privilege_request::GrantPrivilege;
387
388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
389 formatter.write_str("struct user.AlterDefaultPrivilegeRequest.GrantPrivilege")
390 }
391
392 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_default_privilege_request::GrantPrivilege, V::Error>
393 where
394 V: serde::de::MapAccess<'de>,
395 {
396 let mut actions__ = None;
397 let mut object_type__ = None;
398 let mut grantees__ = None;
399 let mut with_grant_option__ = None;
400 while let Some(k) = map_.next_key()? {
401 match k {
402 GeneratedField::Actions => {
403 if actions__.is_some() {
404 return Err(serde::de::Error::duplicate_field("actions"));
405 }
406 actions__ = Some(map_.next_value::<Vec<Action>>()?.into_iter().map(|x| x as i32).collect());
407 }
408 GeneratedField::ObjectType => {
409 if object_type__.is_some() {
410 return Err(serde::de::Error::duplicate_field("objectType"));
411 }
412 object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
413 }
414 GeneratedField::Grantees => {
415 if grantees__.is_some() {
416 return Err(serde::de::Error::duplicate_field("grantees"));
417 }
418 grantees__ =
419 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
420 .into_iter().map(|x| x.0).collect())
421 ;
422 }
423 GeneratedField::WithGrantOption => {
424 if with_grant_option__.is_some() {
425 return Err(serde::de::Error::duplicate_field("withGrantOption"));
426 }
427 with_grant_option__ = Some(map_.next_value()?);
428 }
429 }
430 }
431 Ok(alter_default_privilege_request::GrantPrivilege {
432 actions: actions__.unwrap_or_default(),
433 object_type: object_type__.unwrap_or_default(),
434 grantees: grantees__.unwrap_or_default(),
435 with_grant_option: with_grant_option__.unwrap_or_default(),
436 })
437 }
438 }
439 deserializer.deserialize_struct("user.AlterDefaultPrivilegeRequest.GrantPrivilege", FIELDS, GeneratedVisitor)
440 }
441}
442impl serde::Serialize for alter_default_privilege_request::RevokePrivilege {
443 #[allow(deprecated)]
444 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
445 where
446 S: serde::Serializer,
447 {
448 use serde::ser::SerializeStruct;
449 let mut len = 0;
450 if !self.actions.is_empty() {
451 len += 1;
452 }
453 if self.object_type != 0 {
454 len += 1;
455 }
456 if !self.grantees.is_empty() {
457 len += 1;
458 }
459 if self.revoke_grant_option {
460 len += 1;
461 }
462 let mut struct_ser = serializer.serialize_struct("user.AlterDefaultPrivilegeRequest.RevokePrivilege", len)?;
463 if !self.actions.is_empty() {
464 let v = self.actions.iter().cloned().map(|v| {
465 Action::try_from(v)
466 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
467 }).collect::<std::result::Result<Vec<_>, _>>()?;
468 struct_ser.serialize_field("actions", &v)?;
469 }
470 if self.object_type != 0 {
471 let v = super::common::ObjectType::try_from(self.object_type)
472 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
473 struct_ser.serialize_field("objectType", &v)?;
474 }
475 if !self.grantees.is_empty() {
476 struct_ser.serialize_field("grantees", &self.grantees)?;
477 }
478 if self.revoke_grant_option {
479 struct_ser.serialize_field("revokeGrantOption", &self.revoke_grant_option)?;
480 }
481 struct_ser.end()
482 }
483}
484impl<'de> serde::Deserialize<'de> for alter_default_privilege_request::RevokePrivilege {
485 #[allow(deprecated)]
486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
487 where
488 D: serde::Deserializer<'de>,
489 {
490 const FIELDS: &[&str] = &[
491 "actions",
492 "object_type",
493 "objectType",
494 "grantees",
495 "revoke_grant_option",
496 "revokeGrantOption",
497 ];
498
499 #[allow(clippy::enum_variant_names)]
500 enum GeneratedField {
501 Actions,
502 ObjectType,
503 Grantees,
504 RevokeGrantOption,
505 }
506 impl<'de> serde::Deserialize<'de> for GeneratedField {
507 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
508 where
509 D: serde::Deserializer<'de>,
510 {
511 struct GeneratedVisitor;
512
513 impl serde::de::Visitor<'_> for GeneratedVisitor {
514 type Value = GeneratedField;
515
516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
517 write!(formatter, "expected one of: {:?}", &FIELDS)
518 }
519
520 #[allow(unused_variables)]
521 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
522 where
523 E: serde::de::Error,
524 {
525 match value {
526 "actions" => Ok(GeneratedField::Actions),
527 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
528 "grantees" => Ok(GeneratedField::Grantees),
529 "revokeGrantOption" | "revoke_grant_option" => Ok(GeneratedField::RevokeGrantOption),
530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
531 }
532 }
533 }
534 deserializer.deserialize_identifier(GeneratedVisitor)
535 }
536 }
537 struct GeneratedVisitor;
538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
539 type Value = alter_default_privilege_request::RevokePrivilege;
540
541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
542 formatter.write_str("struct user.AlterDefaultPrivilegeRequest.RevokePrivilege")
543 }
544
545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_default_privilege_request::RevokePrivilege, V::Error>
546 where
547 V: serde::de::MapAccess<'de>,
548 {
549 let mut actions__ = None;
550 let mut object_type__ = None;
551 let mut grantees__ = None;
552 let mut revoke_grant_option__ = None;
553 while let Some(k) = map_.next_key()? {
554 match k {
555 GeneratedField::Actions => {
556 if actions__.is_some() {
557 return Err(serde::de::Error::duplicate_field("actions"));
558 }
559 actions__ = Some(map_.next_value::<Vec<Action>>()?.into_iter().map(|x| x as i32).collect());
560 }
561 GeneratedField::ObjectType => {
562 if object_type__.is_some() {
563 return Err(serde::de::Error::duplicate_field("objectType"));
564 }
565 object_type__ = Some(map_.next_value::<super::common::ObjectType>()? as i32);
566 }
567 GeneratedField::Grantees => {
568 if grantees__.is_some() {
569 return Err(serde::de::Error::duplicate_field("grantees"));
570 }
571 grantees__ =
572 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
573 .into_iter().map(|x| x.0).collect())
574 ;
575 }
576 GeneratedField::RevokeGrantOption => {
577 if revoke_grant_option__.is_some() {
578 return Err(serde::de::Error::duplicate_field("revokeGrantOption"));
579 }
580 revoke_grant_option__ = Some(map_.next_value()?);
581 }
582 }
583 }
584 Ok(alter_default_privilege_request::RevokePrivilege {
585 actions: actions__.unwrap_or_default(),
586 object_type: object_type__.unwrap_or_default(),
587 grantees: grantees__.unwrap_or_default(),
588 revoke_grant_option: revoke_grant_option__.unwrap_or_default(),
589 })
590 }
591 }
592 deserializer.deserialize_struct("user.AlterDefaultPrivilegeRequest.RevokePrivilege", FIELDS, GeneratedVisitor)
593 }
594}
595impl serde::Serialize for AlterDefaultPrivilegeResponse {
596 #[allow(deprecated)]
597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
598 where
599 S: serde::Serializer,
600 {
601 use serde::ser::SerializeStruct;
602 let mut len = 0;
603 if self.status.is_some() {
604 len += 1;
605 }
606 let mut struct_ser = serializer.serialize_struct("user.AlterDefaultPrivilegeResponse", len)?;
607 if let Some(v) = self.status.as_ref() {
608 struct_ser.serialize_field("status", v)?;
609 }
610 struct_ser.end()
611 }
612}
613impl<'de> serde::Deserialize<'de> for AlterDefaultPrivilegeResponse {
614 #[allow(deprecated)]
615 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
616 where
617 D: serde::Deserializer<'de>,
618 {
619 const FIELDS: &[&str] = &[
620 "status",
621 ];
622
623 #[allow(clippy::enum_variant_names)]
624 enum GeneratedField {
625 Status,
626 }
627 impl<'de> serde::Deserialize<'de> for GeneratedField {
628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
629 where
630 D: serde::Deserializer<'de>,
631 {
632 struct GeneratedVisitor;
633
634 impl serde::de::Visitor<'_> for GeneratedVisitor {
635 type Value = GeneratedField;
636
637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
638 write!(formatter, "expected one of: {:?}", &FIELDS)
639 }
640
641 #[allow(unused_variables)]
642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
643 where
644 E: serde::de::Error,
645 {
646 match value {
647 "status" => Ok(GeneratedField::Status),
648 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
649 }
650 }
651 }
652 deserializer.deserialize_identifier(GeneratedVisitor)
653 }
654 }
655 struct GeneratedVisitor;
656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
657 type Value = AlterDefaultPrivilegeResponse;
658
659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
660 formatter.write_str("struct user.AlterDefaultPrivilegeResponse")
661 }
662
663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDefaultPrivilegeResponse, V::Error>
664 where
665 V: serde::de::MapAccess<'de>,
666 {
667 let mut status__ = None;
668 while let Some(k) = map_.next_key()? {
669 match k {
670 GeneratedField::Status => {
671 if status__.is_some() {
672 return Err(serde::de::Error::duplicate_field("status"));
673 }
674 status__ = map_.next_value()?;
675 }
676 }
677 }
678 Ok(AlterDefaultPrivilegeResponse {
679 status: status__,
680 })
681 }
682 }
683 deserializer.deserialize_struct("user.AlterDefaultPrivilegeResponse", FIELDS, GeneratedVisitor)
684 }
685}
686impl serde::Serialize for AuthInfo {
687 #[allow(deprecated)]
688 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
689 where
690 S: serde::Serializer,
691 {
692 use serde::ser::SerializeStruct;
693 let mut len = 0;
694 if self.encryption_type != 0 {
695 len += 1;
696 }
697 if !self.encrypted_value.is_empty() {
698 len += 1;
699 }
700 if !self.metadata.is_empty() {
701 len += 1;
702 }
703 let mut struct_ser = serializer.serialize_struct("user.AuthInfo", len)?;
704 if self.encryption_type != 0 {
705 let v = auth_info::EncryptionType::try_from(self.encryption_type)
706 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encryption_type)))?;
707 struct_ser.serialize_field("encryptionType", &v)?;
708 }
709 if !self.encrypted_value.is_empty() {
710 #[allow(clippy::needless_borrow)]
711 #[allow(clippy::needless_borrows_for_generic_args)]
712 struct_ser.serialize_field("encryptedValue", pbjson::private::base64::encode(&self.encrypted_value).as_str())?;
713 }
714 if !self.metadata.is_empty() {
715 struct_ser.serialize_field("metadata", &self.metadata)?;
716 }
717 struct_ser.end()
718 }
719}
720impl<'de> serde::Deserialize<'de> for AuthInfo {
721 #[allow(deprecated)]
722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
723 where
724 D: serde::Deserializer<'de>,
725 {
726 const FIELDS: &[&str] = &[
727 "encryption_type",
728 "encryptionType",
729 "encrypted_value",
730 "encryptedValue",
731 "metadata",
732 ];
733
734 #[allow(clippy::enum_variant_names)]
735 enum GeneratedField {
736 EncryptionType,
737 EncryptedValue,
738 Metadata,
739 }
740 impl<'de> serde::Deserialize<'de> for GeneratedField {
741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
742 where
743 D: serde::Deserializer<'de>,
744 {
745 struct GeneratedVisitor;
746
747 impl serde::de::Visitor<'_> for GeneratedVisitor {
748 type Value = GeneratedField;
749
750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
751 write!(formatter, "expected one of: {:?}", &FIELDS)
752 }
753
754 #[allow(unused_variables)]
755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
756 where
757 E: serde::de::Error,
758 {
759 match value {
760 "encryptionType" | "encryption_type" => Ok(GeneratedField::EncryptionType),
761 "encryptedValue" | "encrypted_value" => Ok(GeneratedField::EncryptedValue),
762 "metadata" => Ok(GeneratedField::Metadata),
763 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
764 }
765 }
766 }
767 deserializer.deserialize_identifier(GeneratedVisitor)
768 }
769 }
770 struct GeneratedVisitor;
771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
772 type Value = AuthInfo;
773
774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
775 formatter.write_str("struct user.AuthInfo")
776 }
777
778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AuthInfo, V::Error>
779 where
780 V: serde::de::MapAccess<'de>,
781 {
782 let mut encryption_type__ = None;
783 let mut encrypted_value__ = None;
784 let mut metadata__ = None;
785 while let Some(k) = map_.next_key()? {
786 match k {
787 GeneratedField::EncryptionType => {
788 if encryption_type__.is_some() {
789 return Err(serde::de::Error::duplicate_field("encryptionType"));
790 }
791 encryption_type__ = Some(map_.next_value::<auth_info::EncryptionType>()? as i32);
792 }
793 GeneratedField::EncryptedValue => {
794 if encrypted_value__.is_some() {
795 return Err(serde::de::Error::duplicate_field("encryptedValue"));
796 }
797 encrypted_value__ =
798 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
799 ;
800 }
801 GeneratedField::Metadata => {
802 if metadata__.is_some() {
803 return Err(serde::de::Error::duplicate_field("metadata"));
804 }
805 metadata__ = Some(
806 map_.next_value::<std::collections::HashMap<_, _>>()?
807 );
808 }
809 }
810 }
811 Ok(AuthInfo {
812 encryption_type: encryption_type__.unwrap_or_default(),
813 encrypted_value: encrypted_value__.unwrap_or_default(),
814 metadata: metadata__.unwrap_or_default(),
815 })
816 }
817 }
818 deserializer.deserialize_struct("user.AuthInfo", FIELDS, GeneratedVisitor)
819 }
820}
821impl serde::Serialize for auth_info::EncryptionType {
822 #[allow(deprecated)]
823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
824 where
825 S: serde::Serializer,
826 {
827 let variant = match self {
828 Self::Unspecified => "UNSPECIFIED",
829 Self::Plaintext => "PLAINTEXT",
830 Self::Sha256 => "SHA256",
831 Self::Md5 => "MD5",
832 Self::Oauth => "OAUTH",
833 };
834 serializer.serialize_str(variant)
835 }
836}
837impl<'de> serde::Deserialize<'de> for auth_info::EncryptionType {
838 #[allow(deprecated)]
839 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
840 where
841 D: serde::Deserializer<'de>,
842 {
843 const FIELDS: &[&str] = &[
844 "UNSPECIFIED",
845 "PLAINTEXT",
846 "SHA256",
847 "MD5",
848 "OAUTH",
849 ];
850
851 struct GeneratedVisitor;
852
853 impl serde::de::Visitor<'_> for GeneratedVisitor {
854 type Value = auth_info::EncryptionType;
855
856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
857 write!(formatter, "expected one of: {:?}", &FIELDS)
858 }
859
860 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
861 where
862 E: serde::de::Error,
863 {
864 i32::try_from(v)
865 .ok()
866 .and_then(|x| x.try_into().ok())
867 .ok_or_else(|| {
868 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
869 })
870 }
871
872 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
873 where
874 E: serde::de::Error,
875 {
876 i32::try_from(v)
877 .ok()
878 .and_then(|x| x.try_into().ok())
879 .ok_or_else(|| {
880 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
881 })
882 }
883
884 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
885 where
886 E: serde::de::Error,
887 {
888 match value {
889 "UNSPECIFIED" => Ok(auth_info::EncryptionType::Unspecified),
890 "PLAINTEXT" => Ok(auth_info::EncryptionType::Plaintext),
891 "SHA256" => Ok(auth_info::EncryptionType::Sha256),
892 "MD5" => Ok(auth_info::EncryptionType::Md5),
893 "OAUTH" => Ok(auth_info::EncryptionType::Oauth),
894 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
895 }
896 }
897 }
898 deserializer.deserialize_any(GeneratedVisitor)
899 }
900}
901impl serde::Serialize for CreateUserRequest {
902 #[allow(deprecated)]
903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
904 where
905 S: serde::Serializer,
906 {
907 use serde::ser::SerializeStruct;
908 let mut len = 0;
909 if self.user.is_some() {
910 len += 1;
911 }
912 let mut struct_ser = serializer.serialize_struct("user.CreateUserRequest", len)?;
913 if let Some(v) = self.user.as_ref() {
914 struct_ser.serialize_field("user", v)?;
915 }
916 struct_ser.end()
917 }
918}
919impl<'de> serde::Deserialize<'de> for CreateUserRequest {
920 #[allow(deprecated)]
921 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
922 where
923 D: serde::Deserializer<'de>,
924 {
925 const FIELDS: &[&str] = &[
926 "user",
927 ];
928
929 #[allow(clippy::enum_variant_names)]
930 enum GeneratedField {
931 User,
932 }
933 impl<'de> serde::Deserialize<'de> for GeneratedField {
934 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
935 where
936 D: serde::Deserializer<'de>,
937 {
938 struct GeneratedVisitor;
939
940 impl serde::de::Visitor<'_> for GeneratedVisitor {
941 type Value = GeneratedField;
942
943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
944 write!(formatter, "expected one of: {:?}", &FIELDS)
945 }
946
947 #[allow(unused_variables)]
948 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
949 where
950 E: serde::de::Error,
951 {
952 match value {
953 "user" => Ok(GeneratedField::User),
954 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
955 }
956 }
957 }
958 deserializer.deserialize_identifier(GeneratedVisitor)
959 }
960 }
961 struct GeneratedVisitor;
962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
963 type Value = CreateUserRequest;
964
965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
966 formatter.write_str("struct user.CreateUserRequest")
967 }
968
969 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateUserRequest, V::Error>
970 where
971 V: serde::de::MapAccess<'de>,
972 {
973 let mut user__ = None;
974 while let Some(k) = map_.next_key()? {
975 match k {
976 GeneratedField::User => {
977 if user__.is_some() {
978 return Err(serde::de::Error::duplicate_field("user"));
979 }
980 user__ = map_.next_value()?;
981 }
982 }
983 }
984 Ok(CreateUserRequest {
985 user: user__,
986 })
987 }
988 }
989 deserializer.deserialize_struct("user.CreateUserRequest", FIELDS, GeneratedVisitor)
990 }
991}
992impl serde::Serialize for CreateUserResponse {
993 #[allow(deprecated)]
994 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
995 where
996 S: serde::Serializer,
997 {
998 use serde::ser::SerializeStruct;
999 let mut len = 0;
1000 if self.status.is_some() {
1001 len += 1;
1002 }
1003 if self.version != 0 {
1004 len += 1;
1005 }
1006 let mut struct_ser = serializer.serialize_struct("user.CreateUserResponse", len)?;
1007 if let Some(v) = self.status.as_ref() {
1008 struct_ser.serialize_field("status", v)?;
1009 }
1010 if self.version != 0 {
1011 #[allow(clippy::needless_borrow)]
1012 #[allow(clippy::needless_borrows_for_generic_args)]
1013 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
1014 }
1015 struct_ser.end()
1016 }
1017}
1018impl<'de> serde::Deserialize<'de> for CreateUserResponse {
1019 #[allow(deprecated)]
1020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1021 where
1022 D: serde::Deserializer<'de>,
1023 {
1024 const FIELDS: &[&str] = &[
1025 "status",
1026 "version",
1027 ];
1028
1029 #[allow(clippy::enum_variant_names)]
1030 enum GeneratedField {
1031 Status,
1032 Version,
1033 }
1034 impl<'de> serde::Deserialize<'de> for GeneratedField {
1035 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1036 where
1037 D: serde::Deserializer<'de>,
1038 {
1039 struct GeneratedVisitor;
1040
1041 impl serde::de::Visitor<'_> for GeneratedVisitor {
1042 type Value = GeneratedField;
1043
1044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1045 write!(formatter, "expected one of: {:?}", &FIELDS)
1046 }
1047
1048 #[allow(unused_variables)]
1049 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1050 where
1051 E: serde::de::Error,
1052 {
1053 match value {
1054 "status" => Ok(GeneratedField::Status),
1055 "version" => Ok(GeneratedField::Version),
1056 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1057 }
1058 }
1059 }
1060 deserializer.deserialize_identifier(GeneratedVisitor)
1061 }
1062 }
1063 struct GeneratedVisitor;
1064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1065 type Value = CreateUserResponse;
1066
1067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1068 formatter.write_str("struct user.CreateUserResponse")
1069 }
1070
1071 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateUserResponse, V::Error>
1072 where
1073 V: serde::de::MapAccess<'de>,
1074 {
1075 let mut status__ = None;
1076 let mut version__ = None;
1077 while let Some(k) = map_.next_key()? {
1078 match k {
1079 GeneratedField::Status => {
1080 if status__.is_some() {
1081 return Err(serde::de::Error::duplicate_field("status"));
1082 }
1083 status__ = map_.next_value()?;
1084 }
1085 GeneratedField::Version => {
1086 if version__.is_some() {
1087 return Err(serde::de::Error::duplicate_field("version"));
1088 }
1089 version__ =
1090 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1091 ;
1092 }
1093 }
1094 }
1095 Ok(CreateUserResponse {
1096 status: status__,
1097 version: version__.unwrap_or_default(),
1098 })
1099 }
1100 }
1101 deserializer.deserialize_struct("user.CreateUserResponse", FIELDS, GeneratedVisitor)
1102 }
1103}
1104impl serde::Serialize for DropUserRequest {
1105 #[allow(deprecated)]
1106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1107 where
1108 S: serde::Serializer,
1109 {
1110 use serde::ser::SerializeStruct;
1111 let mut len = 0;
1112 if self.user_id != 0 {
1113 len += 1;
1114 }
1115 let mut struct_ser = serializer.serialize_struct("user.DropUserRequest", len)?;
1116 if self.user_id != 0 {
1117 struct_ser.serialize_field("userId", &self.user_id)?;
1118 }
1119 struct_ser.end()
1120 }
1121}
1122impl<'de> serde::Deserialize<'de> for DropUserRequest {
1123 #[allow(deprecated)]
1124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1125 where
1126 D: serde::Deserializer<'de>,
1127 {
1128 const FIELDS: &[&str] = &[
1129 "user_id",
1130 "userId",
1131 ];
1132
1133 #[allow(clippy::enum_variant_names)]
1134 enum GeneratedField {
1135 UserId,
1136 }
1137 impl<'de> serde::Deserialize<'de> for GeneratedField {
1138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1139 where
1140 D: serde::Deserializer<'de>,
1141 {
1142 struct GeneratedVisitor;
1143
1144 impl serde::de::Visitor<'_> for GeneratedVisitor {
1145 type Value = GeneratedField;
1146
1147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1148 write!(formatter, "expected one of: {:?}", &FIELDS)
1149 }
1150
1151 #[allow(unused_variables)]
1152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1153 where
1154 E: serde::de::Error,
1155 {
1156 match value {
1157 "userId" | "user_id" => Ok(GeneratedField::UserId),
1158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1159 }
1160 }
1161 }
1162 deserializer.deserialize_identifier(GeneratedVisitor)
1163 }
1164 }
1165 struct GeneratedVisitor;
1166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1167 type Value = DropUserRequest;
1168
1169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1170 formatter.write_str("struct user.DropUserRequest")
1171 }
1172
1173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropUserRequest, V::Error>
1174 where
1175 V: serde::de::MapAccess<'de>,
1176 {
1177 let mut user_id__ = None;
1178 while let Some(k) = map_.next_key()? {
1179 match k {
1180 GeneratedField::UserId => {
1181 if user_id__.is_some() {
1182 return Err(serde::de::Error::duplicate_field("userId"));
1183 }
1184 user_id__ =
1185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1186 ;
1187 }
1188 }
1189 }
1190 Ok(DropUserRequest {
1191 user_id: user_id__.unwrap_or_default(),
1192 })
1193 }
1194 }
1195 deserializer.deserialize_struct("user.DropUserRequest", FIELDS, GeneratedVisitor)
1196 }
1197}
1198impl serde::Serialize for DropUserResponse {
1199 #[allow(deprecated)]
1200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1201 where
1202 S: serde::Serializer,
1203 {
1204 use serde::ser::SerializeStruct;
1205 let mut len = 0;
1206 if self.status.is_some() {
1207 len += 1;
1208 }
1209 if self.version != 0 {
1210 len += 1;
1211 }
1212 let mut struct_ser = serializer.serialize_struct("user.DropUserResponse", len)?;
1213 if let Some(v) = self.status.as_ref() {
1214 struct_ser.serialize_field("status", v)?;
1215 }
1216 if self.version != 0 {
1217 #[allow(clippy::needless_borrow)]
1218 #[allow(clippy::needless_borrows_for_generic_args)]
1219 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
1220 }
1221 struct_ser.end()
1222 }
1223}
1224impl<'de> serde::Deserialize<'de> for DropUserResponse {
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 "status",
1232 "version",
1233 ];
1234
1235 #[allow(clippy::enum_variant_names)]
1236 enum GeneratedField {
1237 Status,
1238 Version,
1239 }
1240 impl<'de> serde::Deserialize<'de> for GeneratedField {
1241 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1242 where
1243 D: serde::Deserializer<'de>,
1244 {
1245 struct GeneratedVisitor;
1246
1247 impl serde::de::Visitor<'_> for GeneratedVisitor {
1248 type Value = GeneratedField;
1249
1250 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1251 write!(formatter, "expected one of: {:?}", &FIELDS)
1252 }
1253
1254 #[allow(unused_variables)]
1255 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1256 where
1257 E: serde::de::Error,
1258 {
1259 match value {
1260 "status" => Ok(GeneratedField::Status),
1261 "version" => Ok(GeneratedField::Version),
1262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1263 }
1264 }
1265 }
1266 deserializer.deserialize_identifier(GeneratedVisitor)
1267 }
1268 }
1269 struct GeneratedVisitor;
1270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1271 type Value = DropUserResponse;
1272
1273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1274 formatter.write_str("struct user.DropUserResponse")
1275 }
1276
1277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropUserResponse, V::Error>
1278 where
1279 V: serde::de::MapAccess<'de>,
1280 {
1281 let mut status__ = None;
1282 let mut version__ = None;
1283 while let Some(k) = map_.next_key()? {
1284 match k {
1285 GeneratedField::Status => {
1286 if status__.is_some() {
1287 return Err(serde::de::Error::duplicate_field("status"));
1288 }
1289 status__ = map_.next_value()?;
1290 }
1291 GeneratedField::Version => {
1292 if version__.is_some() {
1293 return Err(serde::de::Error::duplicate_field("version"));
1294 }
1295 version__ =
1296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1297 ;
1298 }
1299 }
1300 }
1301 Ok(DropUserResponse {
1302 status: status__,
1303 version: version__.unwrap_or_default(),
1304 })
1305 }
1306 }
1307 deserializer.deserialize_struct("user.DropUserResponse", FIELDS, GeneratedVisitor)
1308 }
1309}
1310impl serde::Serialize for GrantPrivilege {
1311 #[allow(deprecated)]
1312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1313 where
1314 S: serde::Serializer,
1315 {
1316 use serde::ser::SerializeStruct;
1317 let mut len = 0;
1318 if !self.action_with_opts.is_empty() {
1319 len += 1;
1320 }
1321 if self.object.is_some() {
1322 len += 1;
1323 }
1324 let mut struct_ser = serializer.serialize_struct("user.GrantPrivilege", len)?;
1325 if !self.action_with_opts.is_empty() {
1326 struct_ser.serialize_field("actionWithOpts", &self.action_with_opts)?;
1327 }
1328 if let Some(v) = self.object.as_ref() {
1329 match v {
1330 grant_privilege::Object::DatabaseId(v) => {
1331 struct_ser.serialize_field("databaseId", v)?;
1332 }
1333 grant_privilege::Object::SchemaId(v) => {
1334 struct_ser.serialize_field("schemaId", v)?;
1335 }
1336 grant_privilege::Object::TableId(v) => {
1337 struct_ser.serialize_field("tableId", v)?;
1338 }
1339 grant_privilege::Object::SourceId(v) => {
1340 struct_ser.serialize_field("sourceId", v)?;
1341 }
1342 grant_privilege::Object::SinkId(v) => {
1343 struct_ser.serialize_field("sinkId", v)?;
1344 }
1345 grant_privilege::Object::ViewId(v) => {
1346 struct_ser.serialize_field("viewId", v)?;
1347 }
1348 grant_privilege::Object::FunctionId(v) => {
1349 struct_ser.serialize_field("functionId", v)?;
1350 }
1351 grant_privilege::Object::SubscriptionId(v) => {
1352 struct_ser.serialize_field("subscriptionId", v)?;
1353 }
1354 grant_privilege::Object::ConnectionId(v) => {
1355 struct_ser.serialize_field("connectionId", v)?;
1356 }
1357 grant_privilege::Object::SecretId(v) => {
1358 struct_ser.serialize_field("secretId", v)?;
1359 }
1360 }
1361 }
1362 struct_ser.end()
1363 }
1364}
1365impl<'de> serde::Deserialize<'de> for GrantPrivilege {
1366 #[allow(deprecated)]
1367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1368 where
1369 D: serde::Deserializer<'de>,
1370 {
1371 const FIELDS: &[&str] = &[
1372 "action_with_opts",
1373 "actionWithOpts",
1374 "database_id",
1375 "databaseId",
1376 "schema_id",
1377 "schemaId",
1378 "table_id",
1379 "tableId",
1380 "source_id",
1381 "sourceId",
1382 "sink_id",
1383 "sinkId",
1384 "view_id",
1385 "viewId",
1386 "function_id",
1387 "functionId",
1388 "subscription_id",
1389 "subscriptionId",
1390 "connection_id",
1391 "connectionId",
1392 "secret_id",
1393 "secretId",
1394 ];
1395
1396 #[allow(clippy::enum_variant_names)]
1397 enum GeneratedField {
1398 ActionWithOpts,
1399 DatabaseId,
1400 SchemaId,
1401 TableId,
1402 SourceId,
1403 SinkId,
1404 ViewId,
1405 FunctionId,
1406 SubscriptionId,
1407 ConnectionId,
1408 SecretId,
1409 }
1410 impl<'de> serde::Deserialize<'de> for GeneratedField {
1411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1412 where
1413 D: serde::Deserializer<'de>,
1414 {
1415 struct GeneratedVisitor;
1416
1417 impl serde::de::Visitor<'_> for GeneratedVisitor {
1418 type Value = GeneratedField;
1419
1420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1421 write!(formatter, "expected one of: {:?}", &FIELDS)
1422 }
1423
1424 #[allow(unused_variables)]
1425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1426 where
1427 E: serde::de::Error,
1428 {
1429 match value {
1430 "actionWithOpts" | "action_with_opts" => Ok(GeneratedField::ActionWithOpts),
1431 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1432 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1433 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1434 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1435 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1436 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1437 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
1438 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1439 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1440 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1442 }
1443 }
1444 }
1445 deserializer.deserialize_identifier(GeneratedVisitor)
1446 }
1447 }
1448 struct GeneratedVisitor;
1449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1450 type Value = GrantPrivilege;
1451
1452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1453 formatter.write_str("struct user.GrantPrivilege")
1454 }
1455
1456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GrantPrivilege, V::Error>
1457 where
1458 V: serde::de::MapAccess<'de>,
1459 {
1460 let mut action_with_opts__ = None;
1461 let mut object__ = None;
1462 while let Some(k) = map_.next_key()? {
1463 match k {
1464 GeneratedField::ActionWithOpts => {
1465 if action_with_opts__.is_some() {
1466 return Err(serde::de::Error::duplicate_field("actionWithOpts"));
1467 }
1468 action_with_opts__ = Some(map_.next_value()?);
1469 }
1470 GeneratedField::DatabaseId => {
1471 if object__.is_some() {
1472 return Err(serde::de::Error::duplicate_field("databaseId"));
1473 }
1474 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::DatabaseId(x.0));
1475 }
1476 GeneratedField::SchemaId => {
1477 if object__.is_some() {
1478 return Err(serde::de::Error::duplicate_field("schemaId"));
1479 }
1480 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::SchemaId(x.0));
1481 }
1482 GeneratedField::TableId => {
1483 if object__.is_some() {
1484 return Err(serde::de::Error::duplicate_field("tableId"));
1485 }
1486 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::TableId(x.0));
1487 }
1488 GeneratedField::SourceId => {
1489 if object__.is_some() {
1490 return Err(serde::de::Error::duplicate_field("sourceId"));
1491 }
1492 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::SourceId(x.0));
1493 }
1494 GeneratedField::SinkId => {
1495 if object__.is_some() {
1496 return Err(serde::de::Error::duplicate_field("sinkId"));
1497 }
1498 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::SinkId(x.0));
1499 }
1500 GeneratedField::ViewId => {
1501 if object__.is_some() {
1502 return Err(serde::de::Error::duplicate_field("viewId"));
1503 }
1504 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::ViewId(x.0));
1505 }
1506 GeneratedField::FunctionId => {
1507 if object__.is_some() {
1508 return Err(serde::de::Error::duplicate_field("functionId"));
1509 }
1510 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::FunctionId(x.0));
1511 }
1512 GeneratedField::SubscriptionId => {
1513 if object__.is_some() {
1514 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1515 }
1516 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::SubscriptionId(x.0));
1517 }
1518 GeneratedField::ConnectionId => {
1519 if object__.is_some() {
1520 return Err(serde::de::Error::duplicate_field("connectionId"));
1521 }
1522 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::ConnectionId(x.0));
1523 }
1524 GeneratedField::SecretId => {
1525 if object__.is_some() {
1526 return Err(serde::de::Error::duplicate_field("secretId"));
1527 }
1528 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| grant_privilege::Object::SecretId(x.0));
1529 }
1530 }
1531 }
1532 Ok(GrantPrivilege {
1533 action_with_opts: action_with_opts__.unwrap_or_default(),
1534 object: object__,
1535 })
1536 }
1537 }
1538 deserializer.deserialize_struct("user.GrantPrivilege", FIELDS, GeneratedVisitor)
1539 }
1540}
1541impl serde::Serialize for grant_privilege::ActionWithGrantOption {
1542 #[allow(deprecated)]
1543 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1544 where
1545 S: serde::Serializer,
1546 {
1547 use serde::ser::SerializeStruct;
1548 let mut len = 0;
1549 if self.action != 0 {
1550 len += 1;
1551 }
1552 if self.with_grant_option {
1553 len += 1;
1554 }
1555 if self.granted_by != 0 {
1556 len += 1;
1557 }
1558 let mut struct_ser = serializer.serialize_struct("user.GrantPrivilege.ActionWithGrantOption", len)?;
1559 if self.action != 0 {
1560 let v = Action::try_from(self.action)
1561 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.action)))?;
1562 struct_ser.serialize_field("action", &v)?;
1563 }
1564 if self.with_grant_option {
1565 struct_ser.serialize_field("withGrantOption", &self.with_grant_option)?;
1566 }
1567 if self.granted_by != 0 {
1568 struct_ser.serialize_field("grantedBy", &self.granted_by)?;
1569 }
1570 struct_ser.end()
1571 }
1572}
1573impl<'de> serde::Deserialize<'de> for grant_privilege::ActionWithGrantOption {
1574 #[allow(deprecated)]
1575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1576 where
1577 D: serde::Deserializer<'de>,
1578 {
1579 const FIELDS: &[&str] = &[
1580 "action",
1581 "with_grant_option",
1582 "withGrantOption",
1583 "granted_by",
1584 "grantedBy",
1585 ];
1586
1587 #[allow(clippy::enum_variant_names)]
1588 enum GeneratedField {
1589 Action,
1590 WithGrantOption,
1591 GrantedBy,
1592 }
1593 impl<'de> serde::Deserialize<'de> for GeneratedField {
1594 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1595 where
1596 D: serde::Deserializer<'de>,
1597 {
1598 struct GeneratedVisitor;
1599
1600 impl serde::de::Visitor<'_> for GeneratedVisitor {
1601 type Value = GeneratedField;
1602
1603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1604 write!(formatter, "expected one of: {:?}", &FIELDS)
1605 }
1606
1607 #[allow(unused_variables)]
1608 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1609 where
1610 E: serde::de::Error,
1611 {
1612 match value {
1613 "action" => Ok(GeneratedField::Action),
1614 "withGrantOption" | "with_grant_option" => Ok(GeneratedField::WithGrantOption),
1615 "grantedBy" | "granted_by" => Ok(GeneratedField::GrantedBy),
1616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1617 }
1618 }
1619 }
1620 deserializer.deserialize_identifier(GeneratedVisitor)
1621 }
1622 }
1623 struct GeneratedVisitor;
1624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1625 type Value = grant_privilege::ActionWithGrantOption;
1626
1627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1628 formatter.write_str("struct user.GrantPrivilege.ActionWithGrantOption")
1629 }
1630
1631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<grant_privilege::ActionWithGrantOption, V::Error>
1632 where
1633 V: serde::de::MapAccess<'de>,
1634 {
1635 let mut action__ = None;
1636 let mut with_grant_option__ = None;
1637 let mut granted_by__ = None;
1638 while let Some(k) = map_.next_key()? {
1639 match k {
1640 GeneratedField::Action => {
1641 if action__.is_some() {
1642 return Err(serde::de::Error::duplicate_field("action"));
1643 }
1644 action__ = Some(map_.next_value::<Action>()? as i32);
1645 }
1646 GeneratedField::WithGrantOption => {
1647 if with_grant_option__.is_some() {
1648 return Err(serde::de::Error::duplicate_field("withGrantOption"));
1649 }
1650 with_grant_option__ = Some(map_.next_value()?);
1651 }
1652 GeneratedField::GrantedBy => {
1653 if granted_by__.is_some() {
1654 return Err(serde::de::Error::duplicate_field("grantedBy"));
1655 }
1656 granted_by__ =
1657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1658 ;
1659 }
1660 }
1661 }
1662 Ok(grant_privilege::ActionWithGrantOption {
1663 action: action__.unwrap_or_default(),
1664 with_grant_option: with_grant_option__.unwrap_or_default(),
1665 granted_by: granted_by__.unwrap_or_default(),
1666 })
1667 }
1668 }
1669 deserializer.deserialize_struct("user.GrantPrivilege.ActionWithGrantOption", FIELDS, GeneratedVisitor)
1670 }
1671}
1672impl serde::Serialize for GrantPrivilegeRequest {
1673 #[allow(deprecated)]
1674 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1675 where
1676 S: serde::Serializer,
1677 {
1678 use serde::ser::SerializeStruct;
1679 let mut len = 0;
1680 if !self.user_ids.is_empty() {
1681 len += 1;
1682 }
1683 if !self.privileges.is_empty() {
1684 len += 1;
1685 }
1686 if self.with_grant_option {
1687 len += 1;
1688 }
1689 if self.granted_by != 0 {
1690 len += 1;
1691 }
1692 let mut struct_ser = serializer.serialize_struct("user.GrantPrivilegeRequest", len)?;
1693 if !self.user_ids.is_empty() {
1694 struct_ser.serialize_field("userIds", &self.user_ids)?;
1695 }
1696 if !self.privileges.is_empty() {
1697 struct_ser.serialize_field("privileges", &self.privileges)?;
1698 }
1699 if self.with_grant_option {
1700 struct_ser.serialize_field("withGrantOption", &self.with_grant_option)?;
1701 }
1702 if self.granted_by != 0 {
1703 struct_ser.serialize_field("grantedBy", &self.granted_by)?;
1704 }
1705 struct_ser.end()
1706 }
1707}
1708impl<'de> serde::Deserialize<'de> for GrantPrivilegeRequest {
1709 #[allow(deprecated)]
1710 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1711 where
1712 D: serde::Deserializer<'de>,
1713 {
1714 const FIELDS: &[&str] = &[
1715 "user_ids",
1716 "userIds",
1717 "privileges",
1718 "with_grant_option",
1719 "withGrantOption",
1720 "granted_by",
1721 "grantedBy",
1722 ];
1723
1724 #[allow(clippy::enum_variant_names)]
1725 enum GeneratedField {
1726 UserIds,
1727 Privileges,
1728 WithGrantOption,
1729 GrantedBy,
1730 }
1731 impl<'de> serde::Deserialize<'de> for GeneratedField {
1732 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1733 where
1734 D: serde::Deserializer<'de>,
1735 {
1736 struct GeneratedVisitor;
1737
1738 impl serde::de::Visitor<'_> for GeneratedVisitor {
1739 type Value = GeneratedField;
1740
1741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1742 write!(formatter, "expected one of: {:?}", &FIELDS)
1743 }
1744
1745 #[allow(unused_variables)]
1746 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1747 where
1748 E: serde::de::Error,
1749 {
1750 match value {
1751 "userIds" | "user_ids" => Ok(GeneratedField::UserIds),
1752 "privileges" => Ok(GeneratedField::Privileges),
1753 "withGrantOption" | "with_grant_option" => Ok(GeneratedField::WithGrantOption),
1754 "grantedBy" | "granted_by" => Ok(GeneratedField::GrantedBy),
1755 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1756 }
1757 }
1758 }
1759 deserializer.deserialize_identifier(GeneratedVisitor)
1760 }
1761 }
1762 struct GeneratedVisitor;
1763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1764 type Value = GrantPrivilegeRequest;
1765
1766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1767 formatter.write_str("struct user.GrantPrivilegeRequest")
1768 }
1769
1770 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GrantPrivilegeRequest, V::Error>
1771 where
1772 V: serde::de::MapAccess<'de>,
1773 {
1774 let mut user_ids__ = None;
1775 let mut privileges__ = None;
1776 let mut with_grant_option__ = None;
1777 let mut granted_by__ = None;
1778 while let Some(k) = map_.next_key()? {
1779 match k {
1780 GeneratedField::UserIds => {
1781 if user_ids__.is_some() {
1782 return Err(serde::de::Error::duplicate_field("userIds"));
1783 }
1784 user_ids__ =
1785 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1786 .into_iter().map(|x| x.0).collect())
1787 ;
1788 }
1789 GeneratedField::Privileges => {
1790 if privileges__.is_some() {
1791 return Err(serde::de::Error::duplicate_field("privileges"));
1792 }
1793 privileges__ = Some(map_.next_value()?);
1794 }
1795 GeneratedField::WithGrantOption => {
1796 if with_grant_option__.is_some() {
1797 return Err(serde::de::Error::duplicate_field("withGrantOption"));
1798 }
1799 with_grant_option__ = Some(map_.next_value()?);
1800 }
1801 GeneratedField::GrantedBy => {
1802 if granted_by__.is_some() {
1803 return Err(serde::de::Error::duplicate_field("grantedBy"));
1804 }
1805 granted_by__ =
1806 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1807 ;
1808 }
1809 }
1810 }
1811 Ok(GrantPrivilegeRequest {
1812 user_ids: user_ids__.unwrap_or_default(),
1813 privileges: privileges__.unwrap_or_default(),
1814 with_grant_option: with_grant_option__.unwrap_or_default(),
1815 granted_by: granted_by__.unwrap_or_default(),
1816 })
1817 }
1818 }
1819 deserializer.deserialize_struct("user.GrantPrivilegeRequest", FIELDS, GeneratedVisitor)
1820 }
1821}
1822impl serde::Serialize for GrantPrivilegeResponse {
1823 #[allow(deprecated)]
1824 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1825 where
1826 S: serde::Serializer,
1827 {
1828 use serde::ser::SerializeStruct;
1829 let mut len = 0;
1830 if self.status.is_some() {
1831 len += 1;
1832 }
1833 if self.version != 0 {
1834 len += 1;
1835 }
1836 let mut struct_ser = serializer.serialize_struct("user.GrantPrivilegeResponse", len)?;
1837 if let Some(v) = self.status.as_ref() {
1838 struct_ser.serialize_field("status", v)?;
1839 }
1840 if self.version != 0 {
1841 #[allow(clippy::needless_borrow)]
1842 #[allow(clippy::needless_borrows_for_generic_args)]
1843 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
1844 }
1845 struct_ser.end()
1846 }
1847}
1848impl<'de> serde::Deserialize<'de> for GrantPrivilegeResponse {
1849 #[allow(deprecated)]
1850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1851 where
1852 D: serde::Deserializer<'de>,
1853 {
1854 const FIELDS: &[&str] = &[
1855 "status",
1856 "version",
1857 ];
1858
1859 #[allow(clippy::enum_variant_names)]
1860 enum GeneratedField {
1861 Status,
1862 Version,
1863 }
1864 impl<'de> serde::Deserialize<'de> for GeneratedField {
1865 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1866 where
1867 D: serde::Deserializer<'de>,
1868 {
1869 struct GeneratedVisitor;
1870
1871 impl serde::de::Visitor<'_> for GeneratedVisitor {
1872 type Value = GeneratedField;
1873
1874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1875 write!(formatter, "expected one of: {:?}", &FIELDS)
1876 }
1877
1878 #[allow(unused_variables)]
1879 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1880 where
1881 E: serde::de::Error,
1882 {
1883 match value {
1884 "status" => Ok(GeneratedField::Status),
1885 "version" => Ok(GeneratedField::Version),
1886 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1887 }
1888 }
1889 }
1890 deserializer.deserialize_identifier(GeneratedVisitor)
1891 }
1892 }
1893 struct GeneratedVisitor;
1894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1895 type Value = GrantPrivilegeResponse;
1896
1897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1898 formatter.write_str("struct user.GrantPrivilegeResponse")
1899 }
1900
1901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GrantPrivilegeResponse, V::Error>
1902 where
1903 V: serde::de::MapAccess<'de>,
1904 {
1905 let mut status__ = None;
1906 let mut version__ = None;
1907 while let Some(k) = map_.next_key()? {
1908 match k {
1909 GeneratedField::Status => {
1910 if status__.is_some() {
1911 return Err(serde::de::Error::duplicate_field("status"));
1912 }
1913 status__ = map_.next_value()?;
1914 }
1915 GeneratedField::Version => {
1916 if version__.is_some() {
1917 return Err(serde::de::Error::duplicate_field("version"));
1918 }
1919 version__ =
1920 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1921 ;
1922 }
1923 }
1924 }
1925 Ok(GrantPrivilegeResponse {
1926 status: status__,
1927 version: version__.unwrap_or_default(),
1928 })
1929 }
1930 }
1931 deserializer.deserialize_struct("user.GrantPrivilegeResponse", FIELDS, GeneratedVisitor)
1932 }
1933}
1934impl serde::Serialize for RevokePrivilegeRequest {
1935 #[allow(deprecated)]
1936 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1937 where
1938 S: serde::Serializer,
1939 {
1940 use serde::ser::SerializeStruct;
1941 let mut len = 0;
1942 if !self.user_ids.is_empty() {
1943 len += 1;
1944 }
1945 if !self.privileges.is_empty() {
1946 len += 1;
1947 }
1948 if self.granted_by != 0 {
1949 len += 1;
1950 }
1951 if self.revoke_by != 0 {
1952 len += 1;
1953 }
1954 if self.revoke_grant_option {
1955 len += 1;
1956 }
1957 if self.cascade {
1958 len += 1;
1959 }
1960 let mut struct_ser = serializer.serialize_struct("user.RevokePrivilegeRequest", len)?;
1961 if !self.user_ids.is_empty() {
1962 struct_ser.serialize_field("userIds", &self.user_ids)?;
1963 }
1964 if !self.privileges.is_empty() {
1965 struct_ser.serialize_field("privileges", &self.privileges)?;
1966 }
1967 if self.granted_by != 0 {
1968 struct_ser.serialize_field("grantedBy", &self.granted_by)?;
1969 }
1970 if self.revoke_by != 0 {
1971 struct_ser.serialize_field("revokeBy", &self.revoke_by)?;
1972 }
1973 if self.revoke_grant_option {
1974 struct_ser.serialize_field("revokeGrantOption", &self.revoke_grant_option)?;
1975 }
1976 if self.cascade {
1977 struct_ser.serialize_field("cascade", &self.cascade)?;
1978 }
1979 struct_ser.end()
1980 }
1981}
1982impl<'de> serde::Deserialize<'de> for RevokePrivilegeRequest {
1983 #[allow(deprecated)]
1984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1985 where
1986 D: serde::Deserializer<'de>,
1987 {
1988 const FIELDS: &[&str] = &[
1989 "user_ids",
1990 "userIds",
1991 "privileges",
1992 "granted_by",
1993 "grantedBy",
1994 "revoke_by",
1995 "revokeBy",
1996 "revoke_grant_option",
1997 "revokeGrantOption",
1998 "cascade",
1999 ];
2000
2001 #[allow(clippy::enum_variant_names)]
2002 enum GeneratedField {
2003 UserIds,
2004 Privileges,
2005 GrantedBy,
2006 RevokeBy,
2007 RevokeGrantOption,
2008 Cascade,
2009 }
2010 impl<'de> serde::Deserialize<'de> for GeneratedField {
2011 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2012 where
2013 D: serde::Deserializer<'de>,
2014 {
2015 struct GeneratedVisitor;
2016
2017 impl serde::de::Visitor<'_> for GeneratedVisitor {
2018 type Value = GeneratedField;
2019
2020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2021 write!(formatter, "expected one of: {:?}", &FIELDS)
2022 }
2023
2024 #[allow(unused_variables)]
2025 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2026 where
2027 E: serde::de::Error,
2028 {
2029 match value {
2030 "userIds" | "user_ids" => Ok(GeneratedField::UserIds),
2031 "privileges" => Ok(GeneratedField::Privileges),
2032 "grantedBy" | "granted_by" => Ok(GeneratedField::GrantedBy),
2033 "revokeBy" | "revoke_by" => Ok(GeneratedField::RevokeBy),
2034 "revokeGrantOption" | "revoke_grant_option" => Ok(GeneratedField::RevokeGrantOption),
2035 "cascade" => Ok(GeneratedField::Cascade),
2036 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2037 }
2038 }
2039 }
2040 deserializer.deserialize_identifier(GeneratedVisitor)
2041 }
2042 }
2043 struct GeneratedVisitor;
2044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2045 type Value = RevokePrivilegeRequest;
2046
2047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2048 formatter.write_str("struct user.RevokePrivilegeRequest")
2049 }
2050
2051 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RevokePrivilegeRequest, V::Error>
2052 where
2053 V: serde::de::MapAccess<'de>,
2054 {
2055 let mut user_ids__ = None;
2056 let mut privileges__ = None;
2057 let mut granted_by__ = None;
2058 let mut revoke_by__ = None;
2059 let mut revoke_grant_option__ = None;
2060 let mut cascade__ = None;
2061 while let Some(k) = map_.next_key()? {
2062 match k {
2063 GeneratedField::UserIds => {
2064 if user_ids__.is_some() {
2065 return Err(serde::de::Error::duplicate_field("userIds"));
2066 }
2067 user_ids__ =
2068 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2069 .into_iter().map(|x| x.0).collect())
2070 ;
2071 }
2072 GeneratedField::Privileges => {
2073 if privileges__.is_some() {
2074 return Err(serde::de::Error::duplicate_field("privileges"));
2075 }
2076 privileges__ = Some(map_.next_value()?);
2077 }
2078 GeneratedField::GrantedBy => {
2079 if granted_by__.is_some() {
2080 return Err(serde::de::Error::duplicate_field("grantedBy"));
2081 }
2082 granted_by__ =
2083 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2084 ;
2085 }
2086 GeneratedField::RevokeBy => {
2087 if revoke_by__.is_some() {
2088 return Err(serde::de::Error::duplicate_field("revokeBy"));
2089 }
2090 revoke_by__ =
2091 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2092 ;
2093 }
2094 GeneratedField::RevokeGrantOption => {
2095 if revoke_grant_option__.is_some() {
2096 return Err(serde::de::Error::duplicate_field("revokeGrantOption"));
2097 }
2098 revoke_grant_option__ = Some(map_.next_value()?);
2099 }
2100 GeneratedField::Cascade => {
2101 if cascade__.is_some() {
2102 return Err(serde::de::Error::duplicate_field("cascade"));
2103 }
2104 cascade__ = Some(map_.next_value()?);
2105 }
2106 }
2107 }
2108 Ok(RevokePrivilegeRequest {
2109 user_ids: user_ids__.unwrap_or_default(),
2110 privileges: privileges__.unwrap_or_default(),
2111 granted_by: granted_by__.unwrap_or_default(),
2112 revoke_by: revoke_by__.unwrap_or_default(),
2113 revoke_grant_option: revoke_grant_option__.unwrap_or_default(),
2114 cascade: cascade__.unwrap_or_default(),
2115 })
2116 }
2117 }
2118 deserializer.deserialize_struct("user.RevokePrivilegeRequest", FIELDS, GeneratedVisitor)
2119 }
2120}
2121impl serde::Serialize for RevokePrivilegeResponse {
2122 #[allow(deprecated)]
2123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2124 where
2125 S: serde::Serializer,
2126 {
2127 use serde::ser::SerializeStruct;
2128 let mut len = 0;
2129 if self.status.is_some() {
2130 len += 1;
2131 }
2132 if self.version != 0 {
2133 len += 1;
2134 }
2135 let mut struct_ser = serializer.serialize_struct("user.RevokePrivilegeResponse", len)?;
2136 if let Some(v) = self.status.as_ref() {
2137 struct_ser.serialize_field("status", v)?;
2138 }
2139 if self.version != 0 {
2140 #[allow(clippy::needless_borrow)]
2141 #[allow(clippy::needless_borrows_for_generic_args)]
2142 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
2143 }
2144 struct_ser.end()
2145 }
2146}
2147impl<'de> serde::Deserialize<'de> for RevokePrivilegeResponse {
2148 #[allow(deprecated)]
2149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2150 where
2151 D: serde::Deserializer<'de>,
2152 {
2153 const FIELDS: &[&str] = &[
2154 "status",
2155 "version",
2156 ];
2157
2158 #[allow(clippy::enum_variant_names)]
2159 enum GeneratedField {
2160 Status,
2161 Version,
2162 }
2163 impl<'de> serde::Deserialize<'de> for GeneratedField {
2164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2165 where
2166 D: serde::Deserializer<'de>,
2167 {
2168 struct GeneratedVisitor;
2169
2170 impl serde::de::Visitor<'_> for GeneratedVisitor {
2171 type Value = GeneratedField;
2172
2173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2174 write!(formatter, "expected one of: {:?}", &FIELDS)
2175 }
2176
2177 #[allow(unused_variables)]
2178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2179 where
2180 E: serde::de::Error,
2181 {
2182 match value {
2183 "status" => Ok(GeneratedField::Status),
2184 "version" => Ok(GeneratedField::Version),
2185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2186 }
2187 }
2188 }
2189 deserializer.deserialize_identifier(GeneratedVisitor)
2190 }
2191 }
2192 struct GeneratedVisitor;
2193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2194 type Value = RevokePrivilegeResponse;
2195
2196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2197 formatter.write_str("struct user.RevokePrivilegeResponse")
2198 }
2199
2200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RevokePrivilegeResponse, V::Error>
2201 where
2202 V: serde::de::MapAccess<'de>,
2203 {
2204 let mut status__ = None;
2205 let mut version__ = None;
2206 while let Some(k) = map_.next_key()? {
2207 match k {
2208 GeneratedField::Status => {
2209 if status__.is_some() {
2210 return Err(serde::de::Error::duplicate_field("status"));
2211 }
2212 status__ = map_.next_value()?;
2213 }
2214 GeneratedField::Version => {
2215 if version__.is_some() {
2216 return Err(serde::de::Error::duplicate_field("version"));
2217 }
2218 version__ =
2219 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2220 ;
2221 }
2222 }
2223 }
2224 Ok(RevokePrivilegeResponse {
2225 status: status__,
2226 version: version__.unwrap_or_default(),
2227 })
2228 }
2229 }
2230 deserializer.deserialize_struct("user.RevokePrivilegeResponse", FIELDS, GeneratedVisitor)
2231 }
2232}
2233impl serde::Serialize for UpdateUserRequest {
2234 #[allow(deprecated)]
2235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2236 where
2237 S: serde::Serializer,
2238 {
2239 use serde::ser::SerializeStruct;
2240 let mut len = 0;
2241 if self.user.is_some() {
2242 len += 1;
2243 }
2244 if !self.update_fields.is_empty() {
2245 len += 1;
2246 }
2247 let mut struct_ser = serializer.serialize_struct("user.UpdateUserRequest", len)?;
2248 if let Some(v) = self.user.as_ref() {
2249 struct_ser.serialize_field("user", v)?;
2250 }
2251 if !self.update_fields.is_empty() {
2252 let v = self.update_fields.iter().cloned().map(|v| {
2253 update_user_request::UpdateField::try_from(v)
2254 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
2255 }).collect::<std::result::Result<Vec<_>, _>>()?;
2256 struct_ser.serialize_field("updateFields", &v)?;
2257 }
2258 struct_ser.end()
2259 }
2260}
2261impl<'de> serde::Deserialize<'de> for UpdateUserRequest {
2262 #[allow(deprecated)]
2263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2264 where
2265 D: serde::Deserializer<'de>,
2266 {
2267 const FIELDS: &[&str] = &[
2268 "user",
2269 "update_fields",
2270 "updateFields",
2271 ];
2272
2273 #[allow(clippy::enum_variant_names)]
2274 enum GeneratedField {
2275 User,
2276 UpdateFields,
2277 }
2278 impl<'de> serde::Deserialize<'de> for GeneratedField {
2279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2280 where
2281 D: serde::Deserializer<'de>,
2282 {
2283 struct GeneratedVisitor;
2284
2285 impl serde::de::Visitor<'_> for GeneratedVisitor {
2286 type Value = GeneratedField;
2287
2288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2289 write!(formatter, "expected one of: {:?}", &FIELDS)
2290 }
2291
2292 #[allow(unused_variables)]
2293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2294 where
2295 E: serde::de::Error,
2296 {
2297 match value {
2298 "user" => Ok(GeneratedField::User),
2299 "updateFields" | "update_fields" => Ok(GeneratedField::UpdateFields),
2300 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2301 }
2302 }
2303 }
2304 deserializer.deserialize_identifier(GeneratedVisitor)
2305 }
2306 }
2307 struct GeneratedVisitor;
2308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2309 type Value = UpdateUserRequest;
2310
2311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2312 formatter.write_str("struct user.UpdateUserRequest")
2313 }
2314
2315 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateUserRequest, V::Error>
2316 where
2317 V: serde::de::MapAccess<'de>,
2318 {
2319 let mut user__ = None;
2320 let mut update_fields__ = None;
2321 while let Some(k) = map_.next_key()? {
2322 match k {
2323 GeneratedField::User => {
2324 if user__.is_some() {
2325 return Err(serde::de::Error::duplicate_field("user"));
2326 }
2327 user__ = map_.next_value()?;
2328 }
2329 GeneratedField::UpdateFields => {
2330 if update_fields__.is_some() {
2331 return Err(serde::de::Error::duplicate_field("updateFields"));
2332 }
2333 update_fields__ = Some(map_.next_value::<Vec<update_user_request::UpdateField>>()?.into_iter().map(|x| x as i32).collect());
2334 }
2335 }
2336 }
2337 Ok(UpdateUserRequest {
2338 user: user__,
2339 update_fields: update_fields__.unwrap_or_default(),
2340 })
2341 }
2342 }
2343 deserializer.deserialize_struct("user.UpdateUserRequest", FIELDS, GeneratedVisitor)
2344 }
2345}
2346impl serde::Serialize for update_user_request::UpdateField {
2347 #[allow(deprecated)]
2348 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2349 where
2350 S: serde::Serializer,
2351 {
2352 let variant = match self {
2353 Self::Unspecified => "UNSPECIFIED",
2354 Self::Super => "SUPER",
2355 Self::Login => "LOGIN",
2356 Self::CreateDb => "CREATE_DB",
2357 Self::AuthInfo => "AUTH_INFO",
2358 Self::Rename => "RENAME",
2359 Self::CreateUser => "CREATE_USER",
2360 Self::Admin => "ADMIN",
2361 };
2362 serializer.serialize_str(variant)
2363 }
2364}
2365impl<'de> serde::Deserialize<'de> for update_user_request::UpdateField {
2366 #[allow(deprecated)]
2367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2368 where
2369 D: serde::Deserializer<'de>,
2370 {
2371 const FIELDS: &[&str] = &[
2372 "UNSPECIFIED",
2373 "SUPER",
2374 "LOGIN",
2375 "CREATE_DB",
2376 "AUTH_INFO",
2377 "RENAME",
2378 "CREATE_USER",
2379 "ADMIN",
2380 ];
2381
2382 struct GeneratedVisitor;
2383
2384 impl serde::de::Visitor<'_> for GeneratedVisitor {
2385 type Value = update_user_request::UpdateField;
2386
2387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2388 write!(formatter, "expected one of: {:?}", &FIELDS)
2389 }
2390
2391 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2392 where
2393 E: serde::de::Error,
2394 {
2395 i32::try_from(v)
2396 .ok()
2397 .and_then(|x| x.try_into().ok())
2398 .ok_or_else(|| {
2399 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2400 })
2401 }
2402
2403 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2404 where
2405 E: serde::de::Error,
2406 {
2407 i32::try_from(v)
2408 .ok()
2409 .and_then(|x| x.try_into().ok())
2410 .ok_or_else(|| {
2411 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2412 })
2413 }
2414
2415 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2416 where
2417 E: serde::de::Error,
2418 {
2419 match value {
2420 "UNSPECIFIED" => Ok(update_user_request::UpdateField::Unspecified),
2421 "SUPER" => Ok(update_user_request::UpdateField::Super),
2422 "LOGIN" => Ok(update_user_request::UpdateField::Login),
2423 "CREATE_DB" => Ok(update_user_request::UpdateField::CreateDb),
2424 "AUTH_INFO" => Ok(update_user_request::UpdateField::AuthInfo),
2425 "RENAME" => Ok(update_user_request::UpdateField::Rename),
2426 "CREATE_USER" => Ok(update_user_request::UpdateField::CreateUser),
2427 "ADMIN" => Ok(update_user_request::UpdateField::Admin),
2428 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2429 }
2430 }
2431 }
2432 deserializer.deserialize_any(GeneratedVisitor)
2433 }
2434}
2435impl serde::Serialize for UpdateUserResponse {
2436 #[allow(deprecated)]
2437 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2438 where
2439 S: serde::Serializer,
2440 {
2441 use serde::ser::SerializeStruct;
2442 let mut len = 0;
2443 if self.status.is_some() {
2444 len += 1;
2445 }
2446 if self.version != 0 {
2447 len += 1;
2448 }
2449 let mut struct_ser = serializer.serialize_struct("user.UpdateUserResponse", len)?;
2450 if let Some(v) = self.status.as_ref() {
2451 struct_ser.serialize_field("status", v)?;
2452 }
2453 if self.version != 0 {
2454 #[allow(clippy::needless_borrow)]
2455 #[allow(clippy::needless_borrows_for_generic_args)]
2456 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
2457 }
2458 struct_ser.end()
2459 }
2460}
2461impl<'de> serde::Deserialize<'de> for UpdateUserResponse {
2462 #[allow(deprecated)]
2463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2464 where
2465 D: serde::Deserializer<'de>,
2466 {
2467 const FIELDS: &[&str] = &[
2468 "status",
2469 "version",
2470 ];
2471
2472 #[allow(clippy::enum_variant_names)]
2473 enum GeneratedField {
2474 Status,
2475 Version,
2476 }
2477 impl<'de> serde::Deserialize<'de> for GeneratedField {
2478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2479 where
2480 D: serde::Deserializer<'de>,
2481 {
2482 struct GeneratedVisitor;
2483
2484 impl serde::de::Visitor<'_> for GeneratedVisitor {
2485 type Value = GeneratedField;
2486
2487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2488 write!(formatter, "expected one of: {:?}", &FIELDS)
2489 }
2490
2491 #[allow(unused_variables)]
2492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2493 where
2494 E: serde::de::Error,
2495 {
2496 match value {
2497 "status" => Ok(GeneratedField::Status),
2498 "version" => Ok(GeneratedField::Version),
2499 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2500 }
2501 }
2502 }
2503 deserializer.deserialize_identifier(GeneratedVisitor)
2504 }
2505 }
2506 struct GeneratedVisitor;
2507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2508 type Value = UpdateUserResponse;
2509
2510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2511 formatter.write_str("struct user.UpdateUserResponse")
2512 }
2513
2514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateUserResponse, V::Error>
2515 where
2516 V: serde::de::MapAccess<'de>,
2517 {
2518 let mut status__ = None;
2519 let mut version__ = None;
2520 while let Some(k) = map_.next_key()? {
2521 match k {
2522 GeneratedField::Status => {
2523 if status__.is_some() {
2524 return Err(serde::de::Error::duplicate_field("status"));
2525 }
2526 status__ = map_.next_value()?;
2527 }
2528 GeneratedField::Version => {
2529 if version__.is_some() {
2530 return Err(serde::de::Error::duplicate_field("version"));
2531 }
2532 version__ =
2533 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2534 ;
2535 }
2536 }
2537 }
2538 Ok(UpdateUserResponse {
2539 status: status__,
2540 version: version__.unwrap_or_default(),
2541 })
2542 }
2543 }
2544 deserializer.deserialize_struct("user.UpdateUserResponse", FIELDS, GeneratedVisitor)
2545 }
2546}
2547impl serde::Serialize for UserInfo {
2548 #[allow(deprecated)]
2549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2550 where
2551 S: serde::Serializer,
2552 {
2553 use serde::ser::SerializeStruct;
2554 let mut len = 0;
2555 if self.id != 0 {
2556 len += 1;
2557 }
2558 if !self.name.is_empty() {
2559 len += 1;
2560 }
2561 if self.is_super {
2562 len += 1;
2563 }
2564 if self.can_create_db {
2565 len += 1;
2566 }
2567 if self.can_create_user {
2568 len += 1;
2569 }
2570 if self.can_login {
2571 len += 1;
2572 }
2573 if self.auth_info.is_some() {
2574 len += 1;
2575 }
2576 if !self.grant_privileges.is_empty() {
2577 len += 1;
2578 }
2579 if self.is_admin {
2580 len += 1;
2581 }
2582 let mut struct_ser = serializer.serialize_struct("user.UserInfo", len)?;
2583 if self.id != 0 {
2584 struct_ser.serialize_field("id", &self.id)?;
2585 }
2586 if !self.name.is_empty() {
2587 struct_ser.serialize_field("name", &self.name)?;
2588 }
2589 if self.is_super {
2590 struct_ser.serialize_field("isSuper", &self.is_super)?;
2591 }
2592 if self.can_create_db {
2593 struct_ser.serialize_field("canCreateDb", &self.can_create_db)?;
2594 }
2595 if self.can_create_user {
2596 struct_ser.serialize_field("canCreateUser", &self.can_create_user)?;
2597 }
2598 if self.can_login {
2599 struct_ser.serialize_field("canLogin", &self.can_login)?;
2600 }
2601 if let Some(v) = self.auth_info.as_ref() {
2602 struct_ser.serialize_field("authInfo", v)?;
2603 }
2604 if !self.grant_privileges.is_empty() {
2605 struct_ser.serialize_field("grantPrivileges", &self.grant_privileges)?;
2606 }
2607 if self.is_admin {
2608 struct_ser.serialize_field("isAdmin", &self.is_admin)?;
2609 }
2610 struct_ser.end()
2611 }
2612}
2613impl<'de> serde::Deserialize<'de> for UserInfo {
2614 #[allow(deprecated)]
2615 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2616 where
2617 D: serde::Deserializer<'de>,
2618 {
2619 const FIELDS: &[&str] = &[
2620 "id",
2621 "name",
2622 "is_super",
2623 "isSuper",
2624 "can_create_db",
2625 "canCreateDb",
2626 "can_create_user",
2627 "canCreateUser",
2628 "can_login",
2629 "canLogin",
2630 "auth_info",
2631 "authInfo",
2632 "grant_privileges",
2633 "grantPrivileges",
2634 "is_admin",
2635 "isAdmin",
2636 ];
2637
2638 #[allow(clippy::enum_variant_names)]
2639 enum GeneratedField {
2640 Id,
2641 Name,
2642 IsSuper,
2643 CanCreateDb,
2644 CanCreateUser,
2645 CanLogin,
2646 AuthInfo,
2647 GrantPrivileges,
2648 IsAdmin,
2649 }
2650 impl<'de> serde::Deserialize<'de> for GeneratedField {
2651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2652 where
2653 D: serde::Deserializer<'de>,
2654 {
2655 struct GeneratedVisitor;
2656
2657 impl serde::de::Visitor<'_> for GeneratedVisitor {
2658 type Value = GeneratedField;
2659
2660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2661 write!(formatter, "expected one of: {:?}", &FIELDS)
2662 }
2663
2664 #[allow(unused_variables)]
2665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2666 where
2667 E: serde::de::Error,
2668 {
2669 match value {
2670 "id" => Ok(GeneratedField::Id),
2671 "name" => Ok(GeneratedField::Name),
2672 "isSuper" | "is_super" => Ok(GeneratedField::IsSuper),
2673 "canCreateDb" | "can_create_db" => Ok(GeneratedField::CanCreateDb),
2674 "canCreateUser" | "can_create_user" => Ok(GeneratedField::CanCreateUser),
2675 "canLogin" | "can_login" => Ok(GeneratedField::CanLogin),
2676 "authInfo" | "auth_info" => Ok(GeneratedField::AuthInfo),
2677 "grantPrivileges" | "grant_privileges" => Ok(GeneratedField::GrantPrivileges),
2678 "isAdmin" | "is_admin" => Ok(GeneratedField::IsAdmin),
2679 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2680 }
2681 }
2682 }
2683 deserializer.deserialize_identifier(GeneratedVisitor)
2684 }
2685 }
2686 struct GeneratedVisitor;
2687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2688 type Value = UserInfo;
2689
2690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2691 formatter.write_str("struct user.UserInfo")
2692 }
2693
2694 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserInfo, V::Error>
2695 where
2696 V: serde::de::MapAccess<'de>,
2697 {
2698 let mut id__ = None;
2699 let mut name__ = None;
2700 let mut is_super__ = None;
2701 let mut can_create_db__ = None;
2702 let mut can_create_user__ = None;
2703 let mut can_login__ = None;
2704 let mut auth_info__ = None;
2705 let mut grant_privileges__ = None;
2706 let mut is_admin__ = None;
2707 while let Some(k) = map_.next_key()? {
2708 match k {
2709 GeneratedField::Id => {
2710 if id__.is_some() {
2711 return Err(serde::de::Error::duplicate_field("id"));
2712 }
2713 id__ =
2714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2715 ;
2716 }
2717 GeneratedField::Name => {
2718 if name__.is_some() {
2719 return Err(serde::de::Error::duplicate_field("name"));
2720 }
2721 name__ = Some(map_.next_value()?);
2722 }
2723 GeneratedField::IsSuper => {
2724 if is_super__.is_some() {
2725 return Err(serde::de::Error::duplicate_field("isSuper"));
2726 }
2727 is_super__ = Some(map_.next_value()?);
2728 }
2729 GeneratedField::CanCreateDb => {
2730 if can_create_db__.is_some() {
2731 return Err(serde::de::Error::duplicate_field("canCreateDb"));
2732 }
2733 can_create_db__ = Some(map_.next_value()?);
2734 }
2735 GeneratedField::CanCreateUser => {
2736 if can_create_user__.is_some() {
2737 return Err(serde::de::Error::duplicate_field("canCreateUser"));
2738 }
2739 can_create_user__ = Some(map_.next_value()?);
2740 }
2741 GeneratedField::CanLogin => {
2742 if can_login__.is_some() {
2743 return Err(serde::de::Error::duplicate_field("canLogin"));
2744 }
2745 can_login__ = Some(map_.next_value()?);
2746 }
2747 GeneratedField::AuthInfo => {
2748 if auth_info__.is_some() {
2749 return Err(serde::de::Error::duplicate_field("authInfo"));
2750 }
2751 auth_info__ = map_.next_value()?;
2752 }
2753 GeneratedField::GrantPrivileges => {
2754 if grant_privileges__.is_some() {
2755 return Err(serde::de::Error::duplicate_field("grantPrivileges"));
2756 }
2757 grant_privileges__ = Some(map_.next_value()?);
2758 }
2759 GeneratedField::IsAdmin => {
2760 if is_admin__.is_some() {
2761 return Err(serde::de::Error::duplicate_field("isAdmin"));
2762 }
2763 is_admin__ = Some(map_.next_value()?);
2764 }
2765 }
2766 }
2767 Ok(UserInfo {
2768 id: id__.unwrap_or_default(),
2769 name: name__.unwrap_or_default(),
2770 is_super: is_super__.unwrap_or_default(),
2771 can_create_db: can_create_db__.unwrap_or_default(),
2772 can_create_user: can_create_user__.unwrap_or_default(),
2773 can_login: can_login__.unwrap_or_default(),
2774 auth_info: auth_info__,
2775 grant_privileges: grant_privileges__.unwrap_or_default(),
2776 is_admin: is_admin__.unwrap_or_default(),
2777 })
2778 }
2779 }
2780 deserializer.deserialize_struct("user.UserInfo", FIELDS, GeneratedVisitor)
2781 }
2782}