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