1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::secret::*;
4impl serde::Serialize for Secret {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if self.secret_backend.is_some() {
13 len += 1;
14 }
15 let mut struct_ser = serializer.serialize_struct("secret.Secret", len)?;
16 if let Some(v) = self.secret_backend.as_ref() {
17 match v {
18 secret::SecretBackend::Meta(v) => {
19 struct_ser.serialize_field("meta", v)?;
20 }
21 secret::SecretBackend::HashicorpVault(v) => {
22 struct_ser.serialize_field("hashicorpVault", v)?;
23 }
24 }
25 }
26 struct_ser.end()
27 }
28}
29impl<'de> serde::Deserialize<'de> for Secret {
30 #[allow(deprecated)]
31 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
32 where
33 D: serde::Deserializer<'de>,
34 {
35 const FIELDS: &[&str] = &[
36 "meta",
37 "hashicorp_vault",
38 "hashicorpVault",
39 ];
40
41 #[allow(clippy::enum_variant_names)]
42 enum GeneratedField {
43 Meta,
44 HashicorpVault,
45 }
46 impl<'de> serde::Deserialize<'de> for GeneratedField {
47 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
48 where
49 D: serde::Deserializer<'de>,
50 {
51 struct GeneratedVisitor;
52
53 impl serde::de::Visitor<'_> for GeneratedVisitor {
54 type Value = GeneratedField;
55
56 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
57 write!(formatter, "expected one of: {:?}", &FIELDS)
58 }
59
60 #[allow(unused_variables)]
61 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
62 where
63 E: serde::de::Error,
64 {
65 match value {
66 "meta" => Ok(GeneratedField::Meta),
67 "hashicorpVault" | "hashicorp_vault" => Ok(GeneratedField::HashicorpVault),
68 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
69 }
70 }
71 }
72 deserializer.deserialize_identifier(GeneratedVisitor)
73 }
74 }
75 struct GeneratedVisitor;
76 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
77 type Value = Secret;
78
79 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
80 formatter.write_str("struct secret.Secret")
81 }
82
83 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Secret, V::Error>
84 where
85 V: serde::de::MapAccess<'de>,
86 {
87 let mut secret_backend__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::Meta => {
91 if secret_backend__.is_some() {
92 return Err(serde::de::Error::duplicate_field("meta"));
93 }
94 secret_backend__ = map_.next_value::<::std::option::Option<_>>()?.map(secret::SecretBackend::Meta)
95;
96 }
97 GeneratedField::HashicorpVault => {
98 if secret_backend__.is_some() {
99 return Err(serde::de::Error::duplicate_field("hashicorpVault"));
100 }
101 secret_backend__ = map_.next_value::<::std::option::Option<_>>()?.map(secret::SecretBackend::HashicorpVault)
102;
103 }
104 }
105 }
106 Ok(Secret {
107 secret_backend: secret_backend__,
108 })
109 }
110 }
111 deserializer.deserialize_struct("secret.Secret", FIELDS, GeneratedVisitor)
112 }
113}
114impl serde::Serialize for SecretHashicorpVaultBackend {
115 #[allow(deprecated)]
116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
117 where
118 S: serde::Serializer,
119 {
120 use serde::ser::SerializeStruct;
121 let mut len = 0;
122 if !self.addr.is_empty() {
123 len += 1;
124 }
125 if !self.path.is_empty() {
126 len += 1;
127 }
128 if !self.field.is_empty() {
129 len += 1;
130 }
131 if self.tls_skip_verify {
132 len += 1;
133 }
134 if self.auth.is_some() {
135 len += 1;
136 }
137 let mut struct_ser = serializer.serialize_struct("secret.SecretHashicorpVaultBackend", len)?;
138 if !self.addr.is_empty() {
139 struct_ser.serialize_field("addr", &self.addr)?;
140 }
141 if !self.path.is_empty() {
142 struct_ser.serialize_field("path", &self.path)?;
143 }
144 if !self.field.is_empty() {
145 struct_ser.serialize_field("field", &self.field)?;
146 }
147 if self.tls_skip_verify {
148 struct_ser.serialize_field("tlsSkipVerify", &self.tls_skip_verify)?;
149 }
150 if let Some(v) = self.auth.as_ref() {
151 match v {
152 secret_hashicorp_vault_backend::Auth::TokenAuth(v) => {
153 struct_ser.serialize_field("tokenAuth", v)?;
154 }
155 secret_hashicorp_vault_backend::Auth::ApproleAuth(v) => {
156 struct_ser.serialize_field("approleAuth", v)?;
157 }
158 }
159 }
160 struct_ser.end()
161 }
162}
163impl<'de> serde::Deserialize<'de> for SecretHashicorpVaultBackend {
164 #[allow(deprecated)]
165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
166 where
167 D: serde::Deserializer<'de>,
168 {
169 const FIELDS: &[&str] = &[
170 "addr",
171 "path",
172 "field",
173 "tls_skip_verify",
174 "tlsSkipVerify",
175 "token_auth",
176 "tokenAuth",
177 "approle_auth",
178 "approleAuth",
179 ];
180
181 #[allow(clippy::enum_variant_names)]
182 enum GeneratedField {
183 Addr,
184 Path,
185 Field,
186 TlsSkipVerify,
187 TokenAuth,
188 ApproleAuth,
189 }
190 impl<'de> serde::Deserialize<'de> for GeneratedField {
191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
192 where
193 D: serde::Deserializer<'de>,
194 {
195 struct GeneratedVisitor;
196
197 impl serde::de::Visitor<'_> for GeneratedVisitor {
198 type Value = GeneratedField;
199
200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
201 write!(formatter, "expected one of: {:?}", &FIELDS)
202 }
203
204 #[allow(unused_variables)]
205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
206 where
207 E: serde::de::Error,
208 {
209 match value {
210 "addr" => Ok(GeneratedField::Addr),
211 "path" => Ok(GeneratedField::Path),
212 "field" => Ok(GeneratedField::Field),
213 "tlsSkipVerify" | "tls_skip_verify" => Ok(GeneratedField::TlsSkipVerify),
214 "tokenAuth" | "token_auth" => Ok(GeneratedField::TokenAuth),
215 "approleAuth" | "approle_auth" => Ok(GeneratedField::ApproleAuth),
216 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
217 }
218 }
219 }
220 deserializer.deserialize_identifier(GeneratedVisitor)
221 }
222 }
223 struct GeneratedVisitor;
224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
225 type Value = SecretHashicorpVaultBackend;
226
227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
228 formatter.write_str("struct secret.SecretHashicorpVaultBackend")
229 }
230
231 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretHashicorpVaultBackend, V::Error>
232 where
233 V: serde::de::MapAccess<'de>,
234 {
235 let mut addr__ = None;
236 let mut path__ = None;
237 let mut field__ = None;
238 let mut tls_skip_verify__ = None;
239 let mut auth__ = None;
240 while let Some(k) = map_.next_key()? {
241 match k {
242 GeneratedField::Addr => {
243 if addr__.is_some() {
244 return Err(serde::de::Error::duplicate_field("addr"));
245 }
246 addr__ = Some(map_.next_value()?);
247 }
248 GeneratedField::Path => {
249 if path__.is_some() {
250 return Err(serde::de::Error::duplicate_field("path"));
251 }
252 path__ = Some(map_.next_value()?);
253 }
254 GeneratedField::Field => {
255 if field__.is_some() {
256 return Err(serde::de::Error::duplicate_field("field"));
257 }
258 field__ = Some(map_.next_value()?);
259 }
260 GeneratedField::TlsSkipVerify => {
261 if tls_skip_verify__.is_some() {
262 return Err(serde::de::Error::duplicate_field("tlsSkipVerify"));
263 }
264 tls_skip_verify__ = Some(map_.next_value()?);
265 }
266 GeneratedField::TokenAuth => {
267 if auth__.is_some() {
268 return Err(serde::de::Error::duplicate_field("tokenAuth"));
269 }
270 auth__ = map_.next_value::<::std::option::Option<_>>()?.map(secret_hashicorp_vault_backend::Auth::TokenAuth)
271;
272 }
273 GeneratedField::ApproleAuth => {
274 if auth__.is_some() {
275 return Err(serde::de::Error::duplicate_field("approleAuth"));
276 }
277 auth__ = map_.next_value::<::std::option::Option<_>>()?.map(secret_hashicorp_vault_backend::Auth::ApproleAuth)
278;
279 }
280 }
281 }
282 Ok(SecretHashicorpVaultBackend {
283 addr: addr__.unwrap_or_default(),
284 path: path__.unwrap_or_default(),
285 field: field__.unwrap_or_default(),
286 tls_skip_verify: tls_skip_verify__.unwrap_or_default(),
287 auth: auth__,
288 })
289 }
290 }
291 deserializer.deserialize_struct("secret.SecretHashicorpVaultBackend", FIELDS, GeneratedVisitor)
292 }
293}
294impl serde::Serialize for SecretMetaBackend {
295 #[allow(deprecated)]
296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
297 where
298 S: serde::Serializer,
299 {
300 use serde::ser::SerializeStruct;
301 let mut len = 0;
302 if !self.value.is_empty() {
303 len += 1;
304 }
305 let mut struct_ser = serializer.serialize_struct("secret.SecretMetaBackend", len)?;
306 if !self.value.is_empty() {
307 #[allow(clippy::needless_borrow)]
308 #[allow(clippy::needless_borrows_for_generic_args)]
309 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
310 }
311 struct_ser.end()
312 }
313}
314impl<'de> serde::Deserialize<'de> for SecretMetaBackend {
315 #[allow(deprecated)]
316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
317 where
318 D: serde::Deserializer<'de>,
319 {
320 const FIELDS: &[&str] = &[
321 "value",
322 ];
323
324 #[allow(clippy::enum_variant_names)]
325 enum GeneratedField {
326 Value,
327 }
328 impl<'de> serde::Deserialize<'de> for GeneratedField {
329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
330 where
331 D: serde::Deserializer<'de>,
332 {
333 struct GeneratedVisitor;
334
335 impl serde::de::Visitor<'_> for GeneratedVisitor {
336 type Value = GeneratedField;
337
338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
339 write!(formatter, "expected one of: {:?}", &FIELDS)
340 }
341
342 #[allow(unused_variables)]
343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
344 where
345 E: serde::de::Error,
346 {
347 match value {
348 "value" => Ok(GeneratedField::Value),
349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
350 }
351 }
352 }
353 deserializer.deserialize_identifier(GeneratedVisitor)
354 }
355 }
356 struct GeneratedVisitor;
357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
358 type Value = SecretMetaBackend;
359
360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
361 formatter.write_str("struct secret.SecretMetaBackend")
362 }
363
364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretMetaBackend, V::Error>
365 where
366 V: serde::de::MapAccess<'de>,
367 {
368 let mut value__ = None;
369 while let Some(k) = map_.next_key()? {
370 match k {
371 GeneratedField::Value => {
372 if value__.is_some() {
373 return Err(serde::de::Error::duplicate_field("value"));
374 }
375 value__ =
376 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
377 ;
378 }
379 }
380 }
381 Ok(SecretMetaBackend {
382 value: value__.unwrap_or_default(),
383 })
384 }
385 }
386 deserializer.deserialize_struct("secret.SecretMetaBackend", FIELDS, GeneratedVisitor)
387 }
388}
389impl serde::Serialize for SecretRef {
390 #[allow(deprecated)]
391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
392 where
393 S: serde::Serializer,
394 {
395 use serde::ser::SerializeStruct;
396 let mut len = 0;
397 if self.secret_id != 0 {
398 len += 1;
399 }
400 if self.ref_as != 0 {
401 len += 1;
402 }
403 let mut struct_ser = serializer.serialize_struct("secret.SecretRef", len)?;
404 if self.secret_id != 0 {
405 struct_ser.serialize_field("secretId", &self.secret_id)?;
406 }
407 if self.ref_as != 0 {
408 let v = secret_ref::RefAsType::try_from(self.ref_as)
409 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.ref_as)))?;
410 struct_ser.serialize_field("refAs", &v)?;
411 }
412 struct_ser.end()
413 }
414}
415impl<'de> serde::Deserialize<'de> for SecretRef {
416 #[allow(deprecated)]
417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
418 where
419 D: serde::Deserializer<'de>,
420 {
421 const FIELDS: &[&str] = &[
422 "secret_id",
423 "secretId",
424 "ref_as",
425 "refAs",
426 ];
427
428 #[allow(clippy::enum_variant_names)]
429 enum GeneratedField {
430 SecretId,
431 RefAs,
432 }
433 impl<'de> serde::Deserialize<'de> for GeneratedField {
434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
435 where
436 D: serde::Deserializer<'de>,
437 {
438 struct GeneratedVisitor;
439
440 impl serde::de::Visitor<'_> for GeneratedVisitor {
441 type Value = GeneratedField;
442
443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
444 write!(formatter, "expected one of: {:?}", &FIELDS)
445 }
446
447 #[allow(unused_variables)]
448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
449 where
450 E: serde::de::Error,
451 {
452 match value {
453 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
454 "refAs" | "ref_as" => Ok(GeneratedField::RefAs),
455 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
456 }
457 }
458 }
459 deserializer.deserialize_identifier(GeneratedVisitor)
460 }
461 }
462 struct GeneratedVisitor;
463 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
464 type Value = SecretRef;
465
466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
467 formatter.write_str("struct secret.SecretRef")
468 }
469
470 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretRef, V::Error>
471 where
472 V: serde::de::MapAccess<'de>,
473 {
474 let mut secret_id__ = None;
475 let mut ref_as__ = None;
476 while let Some(k) = map_.next_key()? {
477 match k {
478 GeneratedField::SecretId => {
479 if secret_id__.is_some() {
480 return Err(serde::de::Error::duplicate_field("secretId"));
481 }
482 secret_id__ =
483 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
484 ;
485 }
486 GeneratedField::RefAs => {
487 if ref_as__.is_some() {
488 return Err(serde::de::Error::duplicate_field("refAs"));
489 }
490 ref_as__ = Some(map_.next_value::<secret_ref::RefAsType>()? as i32);
491 }
492 }
493 }
494 Ok(SecretRef {
495 secret_id: secret_id__.unwrap_or_default(),
496 ref_as: ref_as__.unwrap_or_default(),
497 })
498 }
499 }
500 deserializer.deserialize_struct("secret.SecretRef", FIELDS, GeneratedVisitor)
501 }
502}
503impl serde::Serialize for secret_ref::RefAsType {
504 #[allow(deprecated)]
505 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
506 where
507 S: serde::Serializer,
508 {
509 let variant = match self {
510 Self::Unspecified => "UNSPECIFIED",
511 Self::Text => "TEXT",
512 Self::File => "FILE",
513 };
514 serializer.serialize_str(variant)
515 }
516}
517impl<'de> serde::Deserialize<'de> for secret_ref::RefAsType {
518 #[allow(deprecated)]
519 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
520 where
521 D: serde::Deserializer<'de>,
522 {
523 const FIELDS: &[&str] = &[
524 "UNSPECIFIED",
525 "TEXT",
526 "FILE",
527 ];
528
529 struct GeneratedVisitor;
530
531 impl serde::de::Visitor<'_> for GeneratedVisitor {
532 type Value = secret_ref::RefAsType;
533
534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
535 write!(formatter, "expected one of: {:?}", &FIELDS)
536 }
537
538 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
539 where
540 E: serde::de::Error,
541 {
542 i32::try_from(v)
543 .ok()
544 .and_then(|x| x.try_into().ok())
545 .ok_or_else(|| {
546 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
547 })
548 }
549
550 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
551 where
552 E: serde::de::Error,
553 {
554 i32::try_from(v)
555 .ok()
556 .and_then(|x| x.try_into().ok())
557 .ok_or_else(|| {
558 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
559 })
560 }
561
562 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
563 where
564 E: serde::de::Error,
565 {
566 match value {
567 "UNSPECIFIED" => Ok(secret_ref::RefAsType::Unspecified),
568 "TEXT" => Ok(secret_ref::RefAsType::Text),
569 "FILE" => Ok(secret_ref::RefAsType::File),
570 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
571 }
572 }
573 }
574 deserializer.deserialize_any(GeneratedVisitor)
575 }
576}
577impl serde::Serialize for VaultAppRoleAuth {
578 #[allow(deprecated)]
579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
580 where
581 S: serde::Serializer,
582 {
583 use serde::ser::SerializeStruct;
584 let mut len = 0;
585 if !self.role_id.is_empty() {
586 len += 1;
587 }
588 if !self.secret_id.is_empty() {
589 len += 1;
590 }
591 let mut struct_ser = serializer.serialize_struct("secret.VaultAppRoleAuth", len)?;
592 if !self.role_id.is_empty() {
593 struct_ser.serialize_field("roleId", &self.role_id)?;
594 }
595 if !self.secret_id.is_empty() {
596 struct_ser.serialize_field("secretId", &self.secret_id)?;
597 }
598 struct_ser.end()
599 }
600}
601impl<'de> serde::Deserialize<'de> for VaultAppRoleAuth {
602 #[allow(deprecated)]
603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
604 where
605 D: serde::Deserializer<'de>,
606 {
607 const FIELDS: &[&str] = &[
608 "role_id",
609 "roleId",
610 "secret_id",
611 "secretId",
612 ];
613
614 #[allow(clippy::enum_variant_names)]
615 enum GeneratedField {
616 RoleId,
617 SecretId,
618 }
619 impl<'de> serde::Deserialize<'de> for GeneratedField {
620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
621 where
622 D: serde::Deserializer<'de>,
623 {
624 struct GeneratedVisitor;
625
626 impl serde::de::Visitor<'_> for GeneratedVisitor {
627 type Value = GeneratedField;
628
629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
630 write!(formatter, "expected one of: {:?}", &FIELDS)
631 }
632
633 #[allow(unused_variables)]
634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
635 where
636 E: serde::de::Error,
637 {
638 match value {
639 "roleId" | "role_id" => Ok(GeneratedField::RoleId),
640 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
642 }
643 }
644 }
645 deserializer.deserialize_identifier(GeneratedVisitor)
646 }
647 }
648 struct GeneratedVisitor;
649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
650 type Value = VaultAppRoleAuth;
651
652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
653 formatter.write_str("struct secret.VaultAppRoleAuth")
654 }
655
656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VaultAppRoleAuth, V::Error>
657 where
658 V: serde::de::MapAccess<'de>,
659 {
660 let mut role_id__ = None;
661 let mut secret_id__ = None;
662 while let Some(k) = map_.next_key()? {
663 match k {
664 GeneratedField::RoleId => {
665 if role_id__.is_some() {
666 return Err(serde::de::Error::duplicate_field("roleId"));
667 }
668 role_id__ = Some(map_.next_value()?);
669 }
670 GeneratedField::SecretId => {
671 if secret_id__.is_some() {
672 return Err(serde::de::Error::duplicate_field("secretId"));
673 }
674 secret_id__ = Some(map_.next_value()?);
675 }
676 }
677 }
678 Ok(VaultAppRoleAuth {
679 role_id: role_id__.unwrap_or_default(),
680 secret_id: secret_id__.unwrap_or_default(),
681 })
682 }
683 }
684 deserializer.deserialize_struct("secret.VaultAppRoleAuth", FIELDS, GeneratedVisitor)
685 }
686}
687impl serde::Serialize for VaultTokenAuth {
688 #[allow(deprecated)]
689 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
690 where
691 S: serde::Serializer,
692 {
693 use serde::ser::SerializeStruct;
694 let mut len = 0;
695 if !self.token.is_empty() {
696 len += 1;
697 }
698 let mut struct_ser = serializer.serialize_struct("secret.VaultTokenAuth", len)?;
699 if !self.token.is_empty() {
700 struct_ser.serialize_field("token", &self.token)?;
701 }
702 struct_ser.end()
703 }
704}
705impl<'de> serde::Deserialize<'de> for VaultTokenAuth {
706 #[allow(deprecated)]
707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
708 where
709 D: serde::Deserializer<'de>,
710 {
711 const FIELDS: &[&str] = &[
712 "token",
713 ];
714
715 #[allow(clippy::enum_variant_names)]
716 enum GeneratedField {
717 Token,
718 }
719 impl<'de> serde::Deserialize<'de> for GeneratedField {
720 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
721 where
722 D: serde::Deserializer<'de>,
723 {
724 struct GeneratedVisitor;
725
726 impl serde::de::Visitor<'_> for GeneratedVisitor {
727 type Value = GeneratedField;
728
729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
730 write!(formatter, "expected one of: {:?}", &FIELDS)
731 }
732
733 #[allow(unused_variables)]
734 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
735 where
736 E: serde::de::Error,
737 {
738 match value {
739 "token" => Ok(GeneratedField::Token),
740 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
741 }
742 }
743 }
744 deserializer.deserialize_identifier(GeneratedVisitor)
745 }
746 }
747 struct GeneratedVisitor;
748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
749 type Value = VaultTokenAuth;
750
751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
752 formatter.write_str("struct secret.VaultTokenAuth")
753 }
754
755 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VaultTokenAuth, V::Error>
756 where
757 V: serde::de::MapAccess<'de>,
758 {
759 let mut token__ = None;
760 while let Some(k) = map_.next_key()? {
761 match k {
762 GeneratedField::Token => {
763 if token__.is_some() {
764 return Err(serde::de::Error::duplicate_field("token"));
765 }
766 token__ = Some(map_.next_value()?);
767 }
768 }
769 }
770 Ok(VaultTokenAuth {
771 token: token__.unwrap_or_default(),
772 })
773 }
774 }
775 deserializer.deserialize_struct("secret.VaultTokenAuth", FIELDS, GeneratedVisitor)
776 }
777}