rust_tdlib/types/
passport_element_type.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Contains the type of a Telegram Passport element
8pub trait TDPassportElementType: Debug + RObject {}
9
10/// Contains the type of a Telegram Passport element
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum PassportElementType {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// A Telegram Passport element containing the user's address
18    #[serde(rename = "passportElementTypeAddress")]
19    Address(PassportElementTypeAddress),
20    /// A Telegram Passport element containing the user's bank statement
21    #[serde(rename = "passportElementTypeBankStatement")]
22    BankStatement(PassportElementTypeBankStatement),
23    /// A Telegram Passport element containing the user's driver license
24    #[serde(rename = "passportElementTypeDriverLicense")]
25    DriverLicense(PassportElementTypeDriverLicense),
26    /// A Telegram Passport element containing the user's email address
27    #[serde(rename = "passportElementTypeEmailAddress")]
28    EmailAddress(PassportElementTypeEmailAddress),
29    /// A Telegram Passport element containing the user's identity card
30    #[serde(rename = "passportElementTypeIdentityCard")]
31    IdentityCard(PassportElementTypeIdentityCard),
32    /// A Telegram Passport element containing the user's internal passport
33    #[serde(rename = "passportElementTypeInternalPassport")]
34    InternalPassport(PassportElementTypeInternalPassport),
35    /// A Telegram Passport element containing the user's passport
36    #[serde(rename = "passportElementTypePassport")]
37    Passport(PassportElementTypePassport),
38    /// A Telegram Passport element containing the registration page of the user's passport
39    #[serde(rename = "passportElementTypePassportRegistration")]
40    PassportRegistration(PassportElementTypePassportRegistration),
41    /// A Telegram Passport element containing the user's personal details
42    #[serde(rename = "passportElementTypePersonalDetails")]
43    PersonalDetails(PassportElementTypePersonalDetails),
44    /// A Telegram Passport element containing the user's phone number
45    #[serde(rename = "passportElementTypePhoneNumber")]
46    PhoneNumber(PassportElementTypePhoneNumber),
47    /// A Telegram Passport element containing the user's rental agreement
48    #[serde(rename = "passportElementTypeRentalAgreement")]
49    RentalAgreement(PassportElementTypeRentalAgreement),
50    /// A Telegram Passport element containing the user's temporary registration
51    #[serde(rename = "passportElementTypeTemporaryRegistration")]
52    TemporaryRegistration(PassportElementTypeTemporaryRegistration),
53    /// A Telegram Passport element containing the user's utility bill
54    #[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/// A Telegram Passport element containing the user's address
118#[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/// A Telegram Passport element containing the user's bank statement
179#[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/// A Telegram Passport element containing the user's driver license
240#[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/// A Telegram Passport element containing the user's email address
301#[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/// A Telegram Passport element containing the user's identity card
362#[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/// A Telegram Passport element containing the user's internal passport
423#[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/// A Telegram Passport element containing the user's passport
484#[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/// A Telegram Passport element containing the registration page of the user's passport
545#[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/// A Telegram Passport element containing the user's personal details
609#[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/// A Telegram Passport element containing the user's phone number
670#[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/// A Telegram Passport element containing the user's rental agreement
731#[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/// A Telegram Passport element containing the user's temporary registration
792#[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/// A Telegram Passport element containing the user's utility bill
856#[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}
rust_tdlib/types/passport_element_type.rs

rust_tdlib/types/
passport_element_type.rs
