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