1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7pub trait TDPassportElementType: Debug + RObject {}
9
10#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum PassportElementType {
14 #[doc(hidden)]
15 #[default]
16 _Default,
17 #[serde(rename = "passportElementTypeAddress")]
19 Address(PassportElementTypeAddress),
20 #[serde(rename = "passportElementTypeBankStatement")]
22 BankStatement(PassportElementTypeBankStatement),
23 #[serde(rename = "passportElementTypeDriverLicense")]
25 DriverLicense(PassportElementTypeDriverLicense),
26 #[serde(rename = "passportElementTypeEmailAddress")]
28 EmailAddress(PassportElementTypeEmailAddress),
29 #[serde(rename = "passportElementTypeIdentityCard")]
31 IdentityCard(PassportElementTypeIdentityCard),
32 #[serde(rename = "passportElementTypeInternalPassport")]
34 InternalPassport(PassportElementTypeInternalPassport),
35 #[serde(rename = "passportElementTypePassport")]
37 Passport(PassportElementTypePassport),
38 #[serde(rename = "passportElementTypePassportRegistration")]
40 PassportRegistration(PassportElementTypePassportRegistration),
41 #[serde(rename = "passportElementTypePersonalDetails")]
43 PersonalDetails(PassportElementTypePersonalDetails),
44 #[serde(rename = "passportElementTypePhoneNumber")]
46 PhoneNumber(PassportElementTypePhoneNumber),
47 #[serde(rename = "passportElementTypeRentalAgreement")]
49 RentalAgreement(PassportElementTypeRentalAgreement),
50 #[serde(rename = "passportElementTypeTemporaryRegistration")]
52 TemporaryRegistration(PassportElementTypeTemporaryRegistration),
53 #[serde(rename = "passportElementTypeUtilityBill")]
55 UtilityBill(PassportElementTypeUtilityBill),
56}
57
58impl RObject for PassportElementType {
59 #[doc(hidden)]
60 fn extra(&self) -> Option<&str> {
61 match self {
62 PassportElementType::Address(t) => t.extra(),
63 PassportElementType::BankStatement(t) => t.extra(),
64 PassportElementType::DriverLicense(t) => t.extra(),
65 PassportElementType::EmailAddress(t) => t.extra(),
66 PassportElementType::IdentityCard(t) => t.extra(),
67 PassportElementType::InternalPassport(t) => t.extra(),
68 PassportElementType::Passport(t) => t.extra(),
69 PassportElementType::PassportRegistration(t) => t.extra(),
70 PassportElementType::PersonalDetails(t) => t.extra(),
71 PassportElementType::PhoneNumber(t) => t.extra(),
72 PassportElementType::RentalAgreement(t) => t.extra(),
73 PassportElementType::TemporaryRegistration(t) => t.extra(),
74 PassportElementType::UtilityBill(t) => t.extra(),
75
76 _ => None,
77 }
78 }
79 #[doc(hidden)]
80 fn client_id(&self) -> Option<i32> {
81 match self {
82 PassportElementType::Address(t) => t.client_id(),
83 PassportElementType::BankStatement(t) => t.client_id(),
84 PassportElementType::DriverLicense(t) => t.client_id(),
85 PassportElementType::EmailAddress(t) => t.client_id(),
86 PassportElementType::IdentityCard(t) => t.client_id(),
87 PassportElementType::InternalPassport(t) => t.client_id(),
88 PassportElementType::Passport(t) => t.client_id(),
89 PassportElementType::PassportRegistration(t) => t.client_id(),
90 PassportElementType::PersonalDetails(t) => t.client_id(),
91 PassportElementType::PhoneNumber(t) => t.client_id(),
92 PassportElementType::RentalAgreement(t) => t.client_id(),
93 PassportElementType::TemporaryRegistration(t) => t.client_id(),
94 PassportElementType::UtilityBill(t) => t.client_id(),
95
96 _ => None,
97 }
98 }
99}
100
101impl PassportElementType {
102 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
103 Ok(serde_json::from_str(json.as_ref())?)
104 }
105 #[doc(hidden)]
106 pub fn _is_default(&self) -> bool {
107 matches!(self, PassportElementType::_Default)
108 }
109}
110
111impl AsRef<PassportElementType> for PassportElementType {
112 fn as_ref(&self) -> &PassportElementType {
113 self
114 }
115}
116
117#[derive(Debug, Clone, Default, Serialize, Deserialize)]
119pub struct PassportElementTypeAddress {
120 #[doc(hidden)]
121 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
122 extra: Option<String>,
123 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
124 client_id: Option<i32>,
125}
126
127impl RObject for PassportElementTypeAddress {
128 #[doc(hidden)]
129 fn extra(&self) -> Option<&str> {
130 self.extra.as_deref()
131 }
132 #[doc(hidden)]
133 fn client_id(&self) -> Option<i32> {
134 self.client_id
135 }
136}
137
138impl TDPassportElementType for PassportElementTypeAddress {}
139
140impl PassportElementTypeAddress {
141 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
142 Ok(serde_json::from_str(json.as_ref())?)
143 }
144 pub fn builder() -> PassportElementTypeAddressBuilder {
145 let mut inner = PassportElementTypeAddress::default();
146 inner.extra = Some(Uuid::new_v4().to_string());
147
148 PassportElementTypeAddressBuilder { inner }
149 }
150}
151
152#[doc(hidden)]
153pub struct PassportElementTypeAddressBuilder {
154 inner: PassportElementTypeAddress,
155}
156
157#[deprecated]
158pub type RTDPassportElementTypeAddressBuilder = PassportElementTypeAddressBuilder;
159
160impl PassportElementTypeAddressBuilder {
161 pub fn build(&self) -> PassportElementTypeAddress {
162 self.inner.clone()
163 }
164}
165
166impl AsRef<PassportElementTypeAddress> for PassportElementTypeAddress {
167 fn as_ref(&self) -> &PassportElementTypeAddress {
168 self
169 }
170}
171
172impl AsRef<PassportElementTypeAddress> for PassportElementTypeAddressBuilder {
173 fn as_ref(&self) -> &PassportElementTypeAddress {
174 &self.inner
175 }
176}
177
178#[derive(Debug, Clone, Default, Serialize, Deserialize)]
180pub struct PassportElementTypeBankStatement {
181 #[doc(hidden)]
182 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
183 extra: Option<String>,
184 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
185 client_id: Option<i32>,
186}
187
188impl RObject for PassportElementTypeBankStatement {
189 #[doc(hidden)]
190 fn extra(&self) -> Option<&str> {
191 self.extra.as_deref()
192 }
193 #[doc(hidden)]
194 fn client_id(&self) -> Option<i32> {
195 self.client_id
196 }
197}
198
199impl TDPassportElementType for PassportElementTypeBankStatement {}
200
201impl PassportElementTypeBankStatement {
202 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
203 Ok(serde_json::from_str(json.as_ref())?)
204 }
205 pub fn builder() -> PassportElementTypeBankStatementBuilder {
206 let mut inner = PassportElementTypeBankStatement::default();
207 inner.extra = Some(Uuid::new_v4().to_string());
208
209 PassportElementTypeBankStatementBuilder { inner }
210 }
211}
212
213#[doc(hidden)]
214pub struct PassportElementTypeBankStatementBuilder {
215 inner: PassportElementTypeBankStatement,
216}
217
218#[deprecated]
219pub type RTDPassportElementTypeBankStatementBuilder = PassportElementTypeBankStatementBuilder;
220
221impl PassportElementTypeBankStatementBuilder {
222 pub fn build(&self) -> PassportElementTypeBankStatement {
223 self.inner.clone()
224 }
225}
226
227impl AsRef<PassportElementTypeBankStatement> for PassportElementTypeBankStatement {
228 fn as_ref(&self) -> &PassportElementTypeBankStatement {
229 self
230 }
231}
232
233impl AsRef<PassportElementTypeBankStatement> for PassportElementTypeBankStatementBuilder {
234 fn as_ref(&self) -> &PassportElementTypeBankStatement {
235 &self.inner
236 }
237}
238
239#[derive(Debug, Clone, Default, Serialize, Deserialize)]
241pub struct PassportElementTypeDriverLicense {
242 #[doc(hidden)]
243 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
244 extra: Option<String>,
245 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
246 client_id: Option<i32>,
247}
248
249impl RObject for PassportElementTypeDriverLicense {
250 #[doc(hidden)]
251 fn extra(&self) -> Option<&str> {
252 self.extra.as_deref()
253 }
254 #[doc(hidden)]
255 fn client_id(&self) -> Option<i32> {
256 self.client_id
257 }
258}
259
260impl TDPassportElementType for PassportElementTypeDriverLicense {}
261
262impl PassportElementTypeDriverLicense {
263 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
264 Ok(serde_json::from_str(json.as_ref())?)
265 }
266 pub fn builder() -> PassportElementTypeDriverLicenseBuilder {
267 let mut inner = PassportElementTypeDriverLicense::default();
268 inner.extra = Some(Uuid::new_v4().to_string());
269
270 PassportElementTypeDriverLicenseBuilder { inner }
271 }
272}
273
274#[doc(hidden)]
275pub struct PassportElementTypeDriverLicenseBuilder {
276 inner: PassportElementTypeDriverLicense,
277}
278
279#[deprecated]
280pub type RTDPassportElementTypeDriverLicenseBuilder = PassportElementTypeDriverLicenseBuilder;
281
282impl PassportElementTypeDriverLicenseBuilder {
283 pub fn build(&self) -> PassportElementTypeDriverLicense {
284 self.inner.clone()
285 }
286}
287
288impl AsRef<PassportElementTypeDriverLicense> for PassportElementTypeDriverLicense {
289 fn as_ref(&self) -> &PassportElementTypeDriverLicense {
290 self
291 }
292}
293
294impl AsRef<PassportElementTypeDriverLicense> for PassportElementTypeDriverLicenseBuilder {
295 fn as_ref(&self) -> &PassportElementTypeDriverLicense {
296 &self.inner
297 }
298}
299
300#[derive(Debug, Clone, Default, Serialize, Deserialize)]
302pub struct PassportElementTypeEmailAddress {
303 #[doc(hidden)]
304 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
305 extra: Option<String>,
306 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
307 client_id: Option<i32>,
308}
309
310impl RObject for PassportElementTypeEmailAddress {
311 #[doc(hidden)]
312 fn extra(&self) -> Option<&str> {
313 self.extra.as_deref()
314 }
315 #[doc(hidden)]
316 fn client_id(&self) -> Option<i32> {
317 self.client_id
318 }
319}
320
321impl TDPassportElementType for PassportElementTypeEmailAddress {}
322
323impl PassportElementTypeEmailAddress {
324 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
325 Ok(serde_json::from_str(json.as_ref())?)
326 }
327 pub fn builder() -> PassportElementTypeEmailAddressBuilder {
328 let mut inner = PassportElementTypeEmailAddress::default();
329 inner.extra = Some(Uuid::new_v4().to_string());
330
331 PassportElementTypeEmailAddressBuilder { inner }
332 }
333}
334
335#[doc(hidden)]
336pub struct PassportElementTypeEmailAddressBuilder {
337 inner: PassportElementTypeEmailAddress,
338}
339
340#[deprecated]
341pub type RTDPassportElementTypeEmailAddressBuilder = PassportElementTypeEmailAddressBuilder;
342
343impl PassportElementTypeEmailAddressBuilder {
344 pub fn build(&self) -> PassportElementTypeEmailAddress {
345 self.inner.clone()
346 }
347}
348
349impl AsRef<PassportElementTypeEmailAddress> for PassportElementTypeEmailAddress {
350 fn as_ref(&self) -> &PassportElementTypeEmailAddress {
351 self
352 }
353}
354
355impl AsRef<PassportElementTypeEmailAddress> for PassportElementTypeEmailAddressBuilder {
356 fn as_ref(&self) -> &PassportElementTypeEmailAddress {
357 &self.inner
358 }
359}
360
361#[derive(Debug, Clone, Default, Serialize, Deserialize)]
363pub struct PassportElementTypeIdentityCard {
364 #[doc(hidden)]
365 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
366 extra: Option<String>,
367 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
368 client_id: Option<i32>,
369}
370
371impl RObject for PassportElementTypeIdentityCard {
372 #[doc(hidden)]
373 fn extra(&self) -> Option<&str> {
374 self.extra.as_deref()
375 }
376 #[doc(hidden)]
377 fn client_id(&self) -> Option<i32> {
378 self.client_id
379 }
380}
381
382impl TDPassportElementType for PassportElementTypeIdentityCard {}
383
384impl PassportElementTypeIdentityCard {
385 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
386 Ok(serde_json::from_str(json.as_ref())?)
387 }
388 pub fn builder() -> PassportElementTypeIdentityCardBuilder {
389 let mut inner = PassportElementTypeIdentityCard::default();
390 inner.extra = Some(Uuid::new_v4().to_string());
391
392 PassportElementTypeIdentityCardBuilder { inner }
393 }
394}
395
396#[doc(hidden)]
397pub struct PassportElementTypeIdentityCardBuilder {
398 inner: PassportElementTypeIdentityCard,
399}
400
401#[deprecated]
402pub type RTDPassportElementTypeIdentityCardBuilder = PassportElementTypeIdentityCardBuilder;
403
404impl PassportElementTypeIdentityCardBuilder {
405 pub fn build(&self) -> PassportElementTypeIdentityCard {
406 self.inner.clone()
407 }
408}
409
410impl AsRef<PassportElementTypeIdentityCard> for PassportElementTypeIdentityCard {
411 fn as_ref(&self) -> &PassportElementTypeIdentityCard {
412 self
413 }
414}
415
416impl AsRef<PassportElementTypeIdentityCard> for PassportElementTypeIdentityCardBuilder {
417 fn as_ref(&self) -> &PassportElementTypeIdentityCard {
418 &self.inner
419 }
420}
421
422#[derive(Debug, Clone, Default, Serialize, Deserialize)]
424pub struct PassportElementTypeInternalPassport {
425 #[doc(hidden)]
426 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
427 extra: Option<String>,
428 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
429 client_id: Option<i32>,
430}
431
432impl RObject for PassportElementTypeInternalPassport {
433 #[doc(hidden)]
434 fn extra(&self) -> Option<&str> {
435 self.extra.as_deref()
436 }
437 #[doc(hidden)]
438 fn client_id(&self) -> Option<i32> {
439 self.client_id
440 }
441}
442
443impl TDPassportElementType for PassportElementTypeInternalPassport {}
444
445impl PassportElementTypeInternalPassport {
446 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
447 Ok(serde_json::from_str(json.as_ref())?)
448 }
449 pub fn builder() -> PassportElementTypeInternalPassportBuilder {
450 let mut inner = PassportElementTypeInternalPassport::default();
451 inner.extra = Some(Uuid::new_v4().to_string());
452
453 PassportElementTypeInternalPassportBuilder { inner }
454 }
455}
456
457#[doc(hidden)]
458pub struct PassportElementTypeInternalPassportBuilder {
459 inner: PassportElementTypeInternalPassport,
460}
461
462#[deprecated]
463pub type RTDPassportElementTypeInternalPassportBuilder = PassportElementTypeInternalPassportBuilder;
464
465impl PassportElementTypeInternalPassportBuilder {
466 pub fn build(&self) -> PassportElementTypeInternalPassport {
467 self.inner.clone()
468 }
469}
470
471impl AsRef<PassportElementTypeInternalPassport> for PassportElementTypeInternalPassport {
472 fn as_ref(&self) -> &PassportElementTypeInternalPassport {
473 self
474 }
475}
476
477impl AsRef<PassportElementTypeInternalPassport> for PassportElementTypeInternalPassportBuilder {
478 fn as_ref(&self) -> &PassportElementTypeInternalPassport {
479 &self.inner
480 }
481}
482
483#[derive(Debug, Clone, Default, Serialize, Deserialize)]
485pub struct PassportElementTypePassport {
486 #[doc(hidden)]
487 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
488 extra: Option<String>,
489 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
490 client_id: Option<i32>,
491}
492
493impl RObject for PassportElementTypePassport {
494 #[doc(hidden)]
495 fn extra(&self) -> Option<&str> {
496 self.extra.as_deref()
497 }
498 #[doc(hidden)]
499 fn client_id(&self) -> Option<i32> {
500 self.client_id
501 }
502}
503
504impl TDPassportElementType for PassportElementTypePassport {}
505
506impl PassportElementTypePassport {
507 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
508 Ok(serde_json::from_str(json.as_ref())?)
509 }
510 pub fn builder() -> PassportElementTypePassportBuilder {
511 let mut inner = PassportElementTypePassport::default();
512 inner.extra = Some(Uuid::new_v4().to_string());
513
514 PassportElementTypePassportBuilder { inner }
515 }
516}
517
518#[doc(hidden)]
519pub struct PassportElementTypePassportBuilder {
520 inner: PassportElementTypePassport,
521}
522
523#[deprecated]
524pub type RTDPassportElementTypePassportBuilder = PassportElementTypePassportBuilder;
525
526impl PassportElementTypePassportBuilder {
527 pub fn build(&self) -> PassportElementTypePassport {
528 self.inner.clone()
529 }
530}
531
532impl AsRef<PassportElementTypePassport> for PassportElementTypePassport {
533 fn as_ref(&self) -> &PassportElementTypePassport {
534 self
535 }
536}
537
538impl AsRef<PassportElementTypePassport> for PassportElementTypePassportBuilder {
539 fn as_ref(&self) -> &PassportElementTypePassport {
540 &self.inner
541 }
542}
543
544#[derive(Debug, Clone, Default, Serialize, Deserialize)]
546pub struct PassportElementTypePassportRegistration {
547 #[doc(hidden)]
548 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
549 extra: Option<String>,
550 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
551 client_id: Option<i32>,
552}
553
554impl RObject for PassportElementTypePassportRegistration {
555 #[doc(hidden)]
556 fn extra(&self) -> Option<&str> {
557 self.extra.as_deref()
558 }
559 #[doc(hidden)]
560 fn client_id(&self) -> Option<i32> {
561 self.client_id
562 }
563}
564
565impl TDPassportElementType for PassportElementTypePassportRegistration {}
566
567impl PassportElementTypePassportRegistration {
568 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
569 Ok(serde_json::from_str(json.as_ref())?)
570 }
571 pub fn builder() -> PassportElementTypePassportRegistrationBuilder {
572 let mut inner = PassportElementTypePassportRegistration::default();
573 inner.extra = Some(Uuid::new_v4().to_string());
574
575 PassportElementTypePassportRegistrationBuilder { inner }
576 }
577}
578
579#[doc(hidden)]
580pub struct PassportElementTypePassportRegistrationBuilder {
581 inner: PassportElementTypePassportRegistration,
582}
583
584#[deprecated]
585pub type RTDPassportElementTypePassportRegistrationBuilder =
586 PassportElementTypePassportRegistrationBuilder;
587
588impl PassportElementTypePassportRegistrationBuilder {
589 pub fn build(&self) -> PassportElementTypePassportRegistration {
590 self.inner.clone()
591 }
592}
593
594impl AsRef<PassportElementTypePassportRegistration> for PassportElementTypePassportRegistration {
595 fn as_ref(&self) -> &PassportElementTypePassportRegistration {
596 self
597 }
598}
599
600impl AsRef<PassportElementTypePassportRegistration>
601 for PassportElementTypePassportRegistrationBuilder
602{
603 fn as_ref(&self) -> &PassportElementTypePassportRegistration {
604 &self.inner
605 }
606}
607
608#[derive(Debug, Clone, Default, Serialize, Deserialize)]
610pub struct PassportElementTypePersonalDetails {
611 #[doc(hidden)]
612 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
613 extra: Option<String>,
614 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
615 client_id: Option<i32>,
616}
617
618impl RObject for PassportElementTypePersonalDetails {
619 #[doc(hidden)]
620 fn extra(&self) -> Option<&str> {
621 self.extra.as_deref()
622 }
623 #[doc(hidden)]
624 fn client_id(&self) -> Option<i32> {
625 self.client_id
626 }
627}
628
629impl TDPassportElementType for PassportElementTypePersonalDetails {}
630
631impl PassportElementTypePersonalDetails {
632 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
633 Ok(serde_json::from_str(json.as_ref())?)
634 }
635 pub fn builder() -> PassportElementTypePersonalDetailsBuilder {
636 let mut inner = PassportElementTypePersonalDetails::default();
637 inner.extra = Some(Uuid::new_v4().to_string());
638
639 PassportElementTypePersonalDetailsBuilder { inner }
640 }
641}
642
643#[doc(hidden)]
644pub struct PassportElementTypePersonalDetailsBuilder {
645 inner: PassportElementTypePersonalDetails,
646}
647
648#[deprecated]
649pub type RTDPassportElementTypePersonalDetailsBuilder = PassportElementTypePersonalDetailsBuilder;
650
651impl PassportElementTypePersonalDetailsBuilder {
652 pub fn build(&self) -> PassportElementTypePersonalDetails {
653 self.inner.clone()
654 }
655}
656
657impl AsRef<PassportElementTypePersonalDetails> for PassportElementTypePersonalDetails {
658 fn as_ref(&self) -> &PassportElementTypePersonalDetails {
659 self
660 }
661}
662
663impl AsRef<PassportElementTypePersonalDetails> for PassportElementTypePersonalDetailsBuilder {
664 fn as_ref(&self) -> &PassportElementTypePersonalDetails {
665 &self.inner
666 }
667}
668
669#[derive(Debug, Clone, Default, Serialize, Deserialize)]
671pub struct PassportElementTypePhoneNumber {
672 #[doc(hidden)]
673 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
674 extra: Option<String>,
675 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
676 client_id: Option<i32>,
677}
678
679impl RObject for PassportElementTypePhoneNumber {
680 #[doc(hidden)]
681 fn extra(&self) -> Option<&str> {
682 self.extra.as_deref()
683 }
684 #[doc(hidden)]
685 fn client_id(&self) -> Option<i32> {
686 self.client_id
687 }
688}
689
690impl TDPassportElementType for PassportElementTypePhoneNumber {}
691
692impl PassportElementTypePhoneNumber {
693 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
694 Ok(serde_json::from_str(json.as_ref())?)
695 }
696 pub fn builder() -> PassportElementTypePhoneNumberBuilder {
697 let mut inner = PassportElementTypePhoneNumber::default();
698 inner.extra = Some(Uuid::new_v4().to_string());
699
700 PassportElementTypePhoneNumberBuilder { inner }
701 }
702}
703
704#[doc(hidden)]
705pub struct PassportElementTypePhoneNumberBuilder {
706 inner: PassportElementTypePhoneNumber,
707}
708
709#[deprecated]
710pub type RTDPassportElementTypePhoneNumberBuilder = PassportElementTypePhoneNumberBuilder;
711
712impl PassportElementTypePhoneNumberBuilder {
713 pub fn build(&self) -> PassportElementTypePhoneNumber {
714 self.inner.clone()
715 }
716}
717
718impl AsRef<PassportElementTypePhoneNumber> for PassportElementTypePhoneNumber {
719 fn as_ref(&self) -> &PassportElementTypePhoneNumber {
720 self
721 }
722}
723
724impl AsRef<PassportElementTypePhoneNumber> for PassportElementTypePhoneNumberBuilder {
725 fn as_ref(&self) -> &PassportElementTypePhoneNumber {
726 &self.inner
727 }
728}
729
730#[derive(Debug, Clone, Default, Serialize, Deserialize)]
732pub struct PassportElementTypeRentalAgreement {
733 #[doc(hidden)]
734 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
735 extra: Option<String>,
736 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
737 client_id: Option<i32>,
738}
739
740impl RObject for PassportElementTypeRentalAgreement {
741 #[doc(hidden)]
742 fn extra(&self) -> Option<&str> {
743 self.extra.as_deref()
744 }
745 #[doc(hidden)]
746 fn client_id(&self) -> Option<i32> {
747 self.client_id
748 }
749}
750
751impl TDPassportElementType for PassportElementTypeRentalAgreement {}
752
753impl PassportElementTypeRentalAgreement {
754 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
755 Ok(serde_json::from_str(json.as_ref())?)
756 }
757 pub fn builder() -> PassportElementTypeRentalAgreementBuilder {
758 let mut inner = PassportElementTypeRentalAgreement::default();
759 inner.extra = Some(Uuid::new_v4().to_string());
760
761 PassportElementTypeRentalAgreementBuilder { inner }
762 }
763}
764
765#[doc(hidden)]
766pub struct PassportElementTypeRentalAgreementBuilder {
767 inner: PassportElementTypeRentalAgreement,
768}
769
770#[deprecated]
771pub type RTDPassportElementTypeRentalAgreementBuilder = PassportElementTypeRentalAgreementBuilder;
772
773impl PassportElementTypeRentalAgreementBuilder {
774 pub fn build(&self) -> PassportElementTypeRentalAgreement {
775 self.inner.clone()
776 }
777}
778
779impl AsRef<PassportElementTypeRentalAgreement> for PassportElementTypeRentalAgreement {
780 fn as_ref(&self) -> &PassportElementTypeRentalAgreement {
781 self
782 }
783}
784
785impl AsRef<PassportElementTypeRentalAgreement> for PassportElementTypeRentalAgreementBuilder {
786 fn as_ref(&self) -> &PassportElementTypeRentalAgreement {
787 &self.inner
788 }
789}
790
791#[derive(Debug, Clone, Default, Serialize, Deserialize)]
793pub struct PassportElementTypeTemporaryRegistration {
794 #[doc(hidden)]
795 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
796 extra: Option<String>,
797 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
798 client_id: Option<i32>,
799}
800
801impl RObject for PassportElementTypeTemporaryRegistration {
802 #[doc(hidden)]
803 fn extra(&self) -> Option<&str> {
804 self.extra.as_deref()
805 }
806 #[doc(hidden)]
807 fn client_id(&self) -> Option<i32> {
808 self.client_id
809 }
810}
811
812impl TDPassportElementType for PassportElementTypeTemporaryRegistration {}
813
814impl PassportElementTypeTemporaryRegistration {
815 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
816 Ok(serde_json::from_str(json.as_ref())?)
817 }
818 pub fn builder() -> PassportElementTypeTemporaryRegistrationBuilder {
819 let mut inner = PassportElementTypeTemporaryRegistration::default();
820 inner.extra = Some(Uuid::new_v4().to_string());
821
822 PassportElementTypeTemporaryRegistrationBuilder { inner }
823 }
824}
825
826#[doc(hidden)]
827pub struct PassportElementTypeTemporaryRegistrationBuilder {
828 inner: PassportElementTypeTemporaryRegistration,
829}
830
831#[deprecated]
832pub type RTDPassportElementTypeTemporaryRegistrationBuilder =
833 PassportElementTypeTemporaryRegistrationBuilder;
834
835impl PassportElementTypeTemporaryRegistrationBuilder {
836 pub fn build(&self) -> PassportElementTypeTemporaryRegistration {
837 self.inner.clone()
838 }
839}
840
841impl AsRef<PassportElementTypeTemporaryRegistration> for PassportElementTypeTemporaryRegistration {
842 fn as_ref(&self) -> &PassportElementTypeTemporaryRegistration {
843 self
844 }
845}
846
847impl AsRef<PassportElementTypeTemporaryRegistration>
848 for PassportElementTypeTemporaryRegistrationBuilder
849{
850 fn as_ref(&self) -> &PassportElementTypeTemporaryRegistration {
851 &self.inner
852 }
853}
854
855#[derive(Debug, Clone, Default, Serialize, Deserialize)]
857pub struct PassportElementTypeUtilityBill {
858 #[doc(hidden)]
859 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
860 extra: Option<String>,
861 #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
862 client_id: Option<i32>,
863}
864
865impl RObject for PassportElementTypeUtilityBill {
866 #[doc(hidden)]
867 fn extra(&self) -> Option<&str> {
868 self.extra.as_deref()
869 }
870 #[doc(hidden)]
871 fn client_id(&self) -> Option<i32> {
872 self.client_id
873 }
874}
875
876impl TDPassportElementType for PassportElementTypeUtilityBill {}
877
878impl PassportElementTypeUtilityBill {
879 pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
880 Ok(serde_json::from_str(json.as_ref())?)
881 }
882 pub fn builder() -> PassportElementTypeUtilityBillBuilder {
883 let mut inner = PassportElementTypeUtilityBill::default();
884 inner.extra = Some(Uuid::new_v4().to_string());
885
886 PassportElementTypeUtilityBillBuilder { inner }
887 }
888}
889
890#[doc(hidden)]
891pub struct PassportElementTypeUtilityBillBuilder {
892 inner: PassportElementTypeUtilityBill,
893}
894
895#[deprecated]
896pub type RTDPassportElementTypeUtilityBillBuilder = PassportElementTypeUtilityBillBuilder;
897
898impl PassportElementTypeUtilityBillBuilder {
899 pub fn build(&self) -> PassportElementTypeUtilityBill {
900 self.inner.clone()
901 }
902}
903
904impl AsRef<PassportElementTypeUtilityBill> for PassportElementTypeUtilityBill {
905 fn as_ref(&self) -> &PassportElementTypeUtilityBill {
906 self
907 }
908}
909
910impl AsRef<PassportElementTypeUtilityBill> for PassportElementTypeUtilityBillBuilder {
911 fn as_ref(&self) -> &PassportElementTypeUtilityBill {
912 &self.inner
913 }
914}