rust_tdlib/types/
passport_element_error_source.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Contains the description of an error in a Telegram Passport element
8pub trait TDPassportElementErrorSource: Debug + RObject {}
9
10/// Contains the description of an error in a Telegram Passport element
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum PassportElementErrorSource {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// One of the data fields contains an error. The error will be considered resolved when the value of the field changes
18    #[serde(rename = "passportElementErrorSourceDataField")]
19    DataField(PassportElementErrorSourceDataField),
20    /// The file contains an error. The error will be considered resolved when the file changes
21    #[serde(rename = "passportElementErrorSourceFile")]
22    File(PassportElementErrorSourceFile),
23    /// The list of attached files contains an error. The error will be considered resolved when the list of files changes
24    #[serde(rename = "passportElementErrorSourceFiles")]
25    Files(PassportElementErrorSourceFiles),
26    /// The front side of the document contains an error. The error will be considered resolved when the file with the front side changes
27    #[serde(rename = "passportElementErrorSourceFrontSide")]
28    FrontSide(PassportElementErrorSourceFrontSide),
29    /// The reverse side of the document contains an error. The error will be considered resolved when the file with the reverse side changes
30    #[serde(rename = "passportElementErrorSourceReverseSide")]
31    ReverseSide(PassportElementErrorSourceReverseSide),
32    /// The selfie with the document contains an error. The error will be considered resolved when the file with the selfie changes
33    #[serde(rename = "passportElementErrorSourceSelfie")]
34    Selfie(PassportElementErrorSourceSelfie),
35    /// One of files with the translation of the document contains an error. The error will be considered resolved when the file changes
36    #[serde(rename = "passportElementErrorSourceTranslationFile")]
37    TranslationFile(PassportElementErrorSourceTranslationFile),
38    /// The translation of the document contains an error. The error will be considered resolved when the list of translation files changes
39    #[serde(rename = "passportElementErrorSourceTranslationFiles")]
40    TranslationFiles(PassportElementErrorSourceTranslationFiles),
41    /// The element contains an error in an unspecified place. The error will be considered resolved when new data is added
42    #[serde(rename = "passportElementErrorSourceUnspecified")]
43    Unspecified(PassportElementErrorSourceUnspecified),
44}
45
46impl RObject for PassportElementErrorSource {
47    #[doc(hidden)]
48    fn extra(&self) -> Option<&str> {
49        match self {
50            PassportElementErrorSource::DataField(t) => t.extra(),
51            PassportElementErrorSource::File(t) => t.extra(),
52            PassportElementErrorSource::Files(t) => t.extra(),
53            PassportElementErrorSource::FrontSide(t) => t.extra(),
54            PassportElementErrorSource::ReverseSide(t) => t.extra(),
55            PassportElementErrorSource::Selfie(t) => t.extra(),
56            PassportElementErrorSource::TranslationFile(t) => t.extra(),
57            PassportElementErrorSource::TranslationFiles(t) => t.extra(),
58            PassportElementErrorSource::Unspecified(t) => t.extra(),
59
60            _ => None,
61        }
62    }
63    #[doc(hidden)]
64    fn client_id(&self) -> Option<i32> {
65        match self {
66            PassportElementErrorSource::DataField(t) => t.client_id(),
67            PassportElementErrorSource::File(t) => t.client_id(),
68            PassportElementErrorSource::Files(t) => t.client_id(),
69            PassportElementErrorSource::FrontSide(t) => t.client_id(),
70            PassportElementErrorSource::ReverseSide(t) => t.client_id(),
71            PassportElementErrorSource::Selfie(t) => t.client_id(),
72            PassportElementErrorSource::TranslationFile(t) => t.client_id(),
73            PassportElementErrorSource::TranslationFiles(t) => t.client_id(),
74            PassportElementErrorSource::Unspecified(t) => t.client_id(),
75
76            _ => None,
77        }
78    }
79}
80
81impl PassportElementErrorSource {
82    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
83        Ok(serde_json::from_str(json.as_ref())?)
84    }
85    #[doc(hidden)]
86    pub fn _is_default(&self) -> bool {
87        matches!(self, PassportElementErrorSource::_Default)
88    }
89}
90
91impl AsRef<PassportElementErrorSource> for PassportElementErrorSource {
92    fn as_ref(&self) -> &PassportElementErrorSource {
93        self
94    }
95}
96
97/// One of the data fields contains an error. The error will be considered resolved when the value of the field changes
98#[derive(Debug, Clone, Default, Serialize, Deserialize)]
99pub struct PassportElementErrorSourceDataField {
100    #[doc(hidden)]
101    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
102    extra: Option<String>,
103    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
104    client_id: Option<i32>,
105    /// Field name
106
107    #[serde(default)]
108    field_name: String,
109}
110
111impl RObject for PassportElementErrorSourceDataField {
112    #[doc(hidden)]
113    fn extra(&self) -> Option<&str> {
114        self.extra.as_deref()
115    }
116    #[doc(hidden)]
117    fn client_id(&self) -> Option<i32> {
118        self.client_id
119    }
120}
121
122impl TDPassportElementErrorSource for PassportElementErrorSourceDataField {}
123
124impl PassportElementErrorSourceDataField {
125    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
126        Ok(serde_json::from_str(json.as_ref())?)
127    }
128    pub fn builder() -> PassportElementErrorSourceDataFieldBuilder {
129        let mut inner = PassportElementErrorSourceDataField::default();
130        inner.extra = Some(Uuid::new_v4().to_string());
131
132        PassportElementErrorSourceDataFieldBuilder { inner }
133    }
134
135    pub fn field_name(&self) -> &String {
136        &self.field_name
137    }
138}
139
140#[doc(hidden)]
141pub struct PassportElementErrorSourceDataFieldBuilder {
142    inner: PassportElementErrorSourceDataField,
143}
144
145#[deprecated]
146pub type RTDPassportElementErrorSourceDataFieldBuilder = PassportElementErrorSourceDataFieldBuilder;
147
148impl PassportElementErrorSourceDataFieldBuilder {
149    pub fn build(&self) -> PassportElementErrorSourceDataField {
150        self.inner.clone()
151    }
152
153    pub fn field_name<T: AsRef<str>>(&mut self, field_name: T) -> &mut Self {
154        self.inner.field_name = field_name.as_ref().to_string();
155        self
156    }
157}
158
159impl AsRef<PassportElementErrorSourceDataField> for PassportElementErrorSourceDataField {
160    fn as_ref(&self) -> &PassportElementErrorSourceDataField {
161        self
162    }
163}
164
165impl AsRef<PassportElementErrorSourceDataField> for PassportElementErrorSourceDataFieldBuilder {
166    fn as_ref(&self) -> &PassportElementErrorSourceDataField {
167        &self.inner
168    }
169}
170
171/// The file contains an error. The error will be considered resolved when the file changes
172#[derive(Debug, Clone, Default, Serialize, Deserialize)]
173pub struct PassportElementErrorSourceFile {
174    #[doc(hidden)]
175    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
176    extra: Option<String>,
177    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
178    client_id: Option<i32>,
179    /// Index of a file with the error
180
181    #[serde(default)]
182    file_index: i32,
183}
184
185impl RObject for PassportElementErrorSourceFile {
186    #[doc(hidden)]
187    fn extra(&self) -> Option<&str> {
188        self.extra.as_deref()
189    }
190    #[doc(hidden)]
191    fn client_id(&self) -> Option<i32> {
192        self.client_id
193    }
194}
195
196impl TDPassportElementErrorSource for PassportElementErrorSourceFile {}
197
198impl PassportElementErrorSourceFile {
199    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
200        Ok(serde_json::from_str(json.as_ref())?)
201    }
202    pub fn builder() -> PassportElementErrorSourceFileBuilder {
203        let mut inner = PassportElementErrorSourceFile::default();
204        inner.extra = Some(Uuid::new_v4().to_string());
205
206        PassportElementErrorSourceFileBuilder { inner }
207    }
208
209    pub fn file_index(&self) -> i32 {
210        self.file_index
211    }
212}
213
214#[doc(hidden)]
215pub struct PassportElementErrorSourceFileBuilder {
216    inner: PassportElementErrorSourceFile,
217}
218
219#[deprecated]
220pub type RTDPassportElementErrorSourceFileBuilder = PassportElementErrorSourceFileBuilder;
221
222impl PassportElementErrorSourceFileBuilder {
223    pub fn build(&self) -> PassportElementErrorSourceFile {
224        self.inner.clone()
225    }
226
227    pub fn file_index(&mut self, file_index: i32) -> &mut Self {
228        self.inner.file_index = file_index;
229        self
230    }
231}
232
233impl AsRef<PassportElementErrorSourceFile> for PassportElementErrorSourceFile {
234    fn as_ref(&self) -> &PassportElementErrorSourceFile {
235        self
236    }
237}
238
239impl AsRef<PassportElementErrorSourceFile> for PassportElementErrorSourceFileBuilder {
240    fn as_ref(&self) -> &PassportElementErrorSourceFile {
241        &self.inner
242    }
243}
244
245/// The list of attached files contains an error. The error will be considered resolved when the list of files changes
246#[derive(Debug, Clone, Default, Serialize, Deserialize)]
247pub struct PassportElementErrorSourceFiles {
248    #[doc(hidden)]
249    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
250    extra: Option<String>,
251    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
252    client_id: Option<i32>,
253}
254
255impl RObject for PassportElementErrorSourceFiles {
256    #[doc(hidden)]
257    fn extra(&self) -> Option<&str> {
258        self.extra.as_deref()
259    }
260    #[doc(hidden)]
261    fn client_id(&self) -> Option<i32> {
262        self.client_id
263    }
264}
265
266impl TDPassportElementErrorSource for PassportElementErrorSourceFiles {}
267
268impl PassportElementErrorSourceFiles {
269    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
270        Ok(serde_json::from_str(json.as_ref())?)
271    }
272    pub fn builder() -> PassportElementErrorSourceFilesBuilder {
273        let mut inner = PassportElementErrorSourceFiles::default();
274        inner.extra = Some(Uuid::new_v4().to_string());
275
276        PassportElementErrorSourceFilesBuilder { inner }
277    }
278}
279
280#[doc(hidden)]
281pub struct PassportElementErrorSourceFilesBuilder {
282    inner: PassportElementErrorSourceFiles,
283}
284
285#[deprecated]
286pub type RTDPassportElementErrorSourceFilesBuilder = PassportElementErrorSourceFilesBuilder;
287
288impl PassportElementErrorSourceFilesBuilder {
289    pub fn build(&self) -> PassportElementErrorSourceFiles {
290        self.inner.clone()
291    }
292}
293
294impl AsRef<PassportElementErrorSourceFiles> for PassportElementErrorSourceFiles {
295    fn as_ref(&self) -> &PassportElementErrorSourceFiles {
296        self
297    }
298}
299
300impl AsRef<PassportElementErrorSourceFiles> for PassportElementErrorSourceFilesBuilder {
301    fn as_ref(&self) -> &PassportElementErrorSourceFiles {
302        &self.inner
303    }
304}
305
306/// The front side of the document contains an error. The error will be considered resolved when the file with the front side changes
307#[derive(Debug, Clone, Default, Serialize, Deserialize)]
308pub struct PassportElementErrorSourceFrontSide {
309    #[doc(hidden)]
310    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
311    extra: Option<String>,
312    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
313    client_id: Option<i32>,
314}
315
316impl RObject for PassportElementErrorSourceFrontSide {
317    #[doc(hidden)]
318    fn extra(&self) -> Option<&str> {
319        self.extra.as_deref()
320    }
321    #[doc(hidden)]
322    fn client_id(&self) -> Option<i32> {
323        self.client_id
324    }
325}
326
327impl TDPassportElementErrorSource for PassportElementErrorSourceFrontSide {}
328
329impl PassportElementErrorSourceFrontSide {
330    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
331        Ok(serde_json::from_str(json.as_ref())?)
332    }
333    pub fn builder() -> PassportElementErrorSourceFrontSideBuilder {
334        let mut inner = PassportElementErrorSourceFrontSide::default();
335        inner.extra = Some(Uuid::new_v4().to_string());
336
337        PassportElementErrorSourceFrontSideBuilder { inner }
338    }
339}
340
341#[doc(hidden)]
342pub struct PassportElementErrorSourceFrontSideBuilder {
343    inner: PassportElementErrorSourceFrontSide,
344}
345
346#[deprecated]
347pub type RTDPassportElementErrorSourceFrontSideBuilder = PassportElementErrorSourceFrontSideBuilder;
348
349impl PassportElementErrorSourceFrontSideBuilder {
350    pub fn build(&self) -> PassportElementErrorSourceFrontSide {
351        self.inner.clone()
352    }
353}
354
355impl AsRef<PassportElementErrorSourceFrontSide> for PassportElementErrorSourceFrontSide {
356    fn as_ref(&self) -> &PassportElementErrorSourceFrontSide {
357        self
358    }
359}
360
361impl AsRef<PassportElementErrorSourceFrontSide> for PassportElementErrorSourceFrontSideBuilder {
362    fn as_ref(&self) -> &PassportElementErrorSourceFrontSide {
363        &self.inner
364    }
365}
366
367/// The reverse side of the document contains an error. The error will be considered resolved when the file with the reverse side changes
368#[derive(Debug, Clone, Default, Serialize, Deserialize)]
369pub struct PassportElementErrorSourceReverseSide {
370    #[doc(hidden)]
371    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
372    extra: Option<String>,
373    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
374    client_id: Option<i32>,
375}
376
377impl RObject for PassportElementErrorSourceReverseSide {
378    #[doc(hidden)]
379    fn extra(&self) -> Option<&str> {
380        self.extra.as_deref()
381    }
382    #[doc(hidden)]
383    fn client_id(&self) -> Option<i32> {
384        self.client_id
385    }
386}
387
388impl TDPassportElementErrorSource for PassportElementErrorSourceReverseSide {}
389
390impl PassportElementErrorSourceReverseSide {
391    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
392        Ok(serde_json::from_str(json.as_ref())?)
393    }
394    pub fn builder() -> PassportElementErrorSourceReverseSideBuilder {
395        let mut inner = PassportElementErrorSourceReverseSide::default();
396        inner.extra = Some(Uuid::new_v4().to_string());
397
398        PassportElementErrorSourceReverseSideBuilder { inner }
399    }
400}
401
402#[doc(hidden)]
403pub struct PassportElementErrorSourceReverseSideBuilder {
404    inner: PassportElementErrorSourceReverseSide,
405}
406
407#[deprecated]
408pub type RTDPassportElementErrorSourceReverseSideBuilder =
409    PassportElementErrorSourceReverseSideBuilder;
410
411impl PassportElementErrorSourceReverseSideBuilder {
412    pub fn build(&self) -> PassportElementErrorSourceReverseSide {
413        self.inner.clone()
414    }
415}
416
417impl AsRef<PassportElementErrorSourceReverseSide> for PassportElementErrorSourceReverseSide {
418    fn as_ref(&self) -> &PassportElementErrorSourceReverseSide {
419        self
420    }
421}
422
423impl AsRef<PassportElementErrorSourceReverseSide> for PassportElementErrorSourceReverseSideBuilder {
424    fn as_ref(&self) -> &PassportElementErrorSourceReverseSide {
425        &self.inner
426    }
427}
428
429/// The selfie with the document contains an error. The error will be considered resolved when the file with the selfie changes
430#[derive(Debug, Clone, Default, Serialize, Deserialize)]
431pub struct PassportElementErrorSourceSelfie {
432    #[doc(hidden)]
433    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
434    extra: Option<String>,
435    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
436    client_id: Option<i32>,
437}
438
439impl RObject for PassportElementErrorSourceSelfie {
440    #[doc(hidden)]
441    fn extra(&self) -> Option<&str> {
442        self.extra.as_deref()
443    }
444    #[doc(hidden)]
445    fn client_id(&self) -> Option<i32> {
446        self.client_id
447    }
448}
449
450impl TDPassportElementErrorSource for PassportElementErrorSourceSelfie {}
451
452impl PassportElementErrorSourceSelfie {
453    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
454        Ok(serde_json::from_str(json.as_ref())?)
455    }
456    pub fn builder() -> PassportElementErrorSourceSelfieBuilder {
457        let mut inner = PassportElementErrorSourceSelfie::default();
458        inner.extra = Some(Uuid::new_v4().to_string());
459
460        PassportElementErrorSourceSelfieBuilder { inner }
461    }
462}
463
464#[doc(hidden)]
465pub struct PassportElementErrorSourceSelfieBuilder {
466    inner: PassportElementErrorSourceSelfie,
467}
468
469#[deprecated]
470pub type RTDPassportElementErrorSourceSelfieBuilder = PassportElementErrorSourceSelfieBuilder;
471
472impl PassportElementErrorSourceSelfieBuilder {
473    pub fn build(&self) -> PassportElementErrorSourceSelfie {
474        self.inner.clone()
475    }
476}
477
478impl AsRef<PassportElementErrorSourceSelfie> for PassportElementErrorSourceSelfie {
479    fn as_ref(&self) -> &PassportElementErrorSourceSelfie {
480        self
481    }
482}
483
484impl AsRef<PassportElementErrorSourceSelfie> for PassportElementErrorSourceSelfieBuilder {
485    fn as_ref(&self) -> &PassportElementErrorSourceSelfie {
486        &self.inner
487    }
488}
489
490/// One of files with the translation of the document contains an error. The error will be considered resolved when the file changes
491#[derive(Debug, Clone, Default, Serialize, Deserialize)]
492pub struct PassportElementErrorSourceTranslationFile {
493    #[doc(hidden)]
494    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
495    extra: Option<String>,
496    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
497    client_id: Option<i32>,
498    /// Index of a file with the error
499
500    #[serde(default)]
501    file_index: i32,
502}
503
504impl RObject for PassportElementErrorSourceTranslationFile {
505    #[doc(hidden)]
506    fn extra(&self) -> Option<&str> {
507        self.extra.as_deref()
508    }
509    #[doc(hidden)]
510    fn client_id(&self) -> Option<i32> {
511        self.client_id
512    }
513}
514
515impl TDPassportElementErrorSource for PassportElementErrorSourceTranslationFile {}
516
517impl PassportElementErrorSourceTranslationFile {
518    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
519        Ok(serde_json::from_str(json.as_ref())?)
520    }
521    pub fn builder() -> PassportElementErrorSourceTranslationFileBuilder {
522        let mut inner = PassportElementErrorSourceTranslationFile::default();
523        inner.extra = Some(Uuid::new_v4().to_string());
524
525        PassportElementErrorSourceTranslationFileBuilder { inner }
526    }
527
528    pub fn file_index(&self) -> i32 {
529        self.file_index
530    }
531}
532
533#[doc(hidden)]
534pub struct PassportElementErrorSourceTranslationFileBuilder {
535    inner: PassportElementErrorSourceTranslationFile,
536}
537
538#[deprecated]
539pub type RTDPassportElementErrorSourceTranslationFileBuilder =
540    PassportElementErrorSourceTranslationFileBuilder;
541
542impl PassportElementErrorSourceTranslationFileBuilder {
543    pub fn build(&self) -> PassportElementErrorSourceTranslationFile {
544        self.inner.clone()
545    }
546
547    pub fn file_index(&mut self, file_index: i32) -> &mut Self {
548        self.inner.file_index = file_index;
549        self
550    }
551}
552
553impl AsRef<PassportElementErrorSourceTranslationFile>
554    for PassportElementErrorSourceTranslationFile
555{
556    fn as_ref(&self) -> &PassportElementErrorSourceTranslationFile {
557        self
558    }
559}
560
561impl AsRef<PassportElementErrorSourceTranslationFile>
562    for PassportElementErrorSourceTranslationFileBuilder
563{
564    fn as_ref(&self) -> &PassportElementErrorSourceTranslationFile {
565        &self.inner
566    }
567}
568
569/// The translation of the document contains an error. The error will be considered resolved when the list of translation files changes
570#[derive(Debug, Clone, Default, Serialize, Deserialize)]
571pub struct PassportElementErrorSourceTranslationFiles {
572    #[doc(hidden)]
573    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
574    extra: Option<String>,
575    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
576    client_id: Option<i32>,
577}
578
579impl RObject for PassportElementErrorSourceTranslationFiles {
580    #[doc(hidden)]
581    fn extra(&self) -> Option<&str> {
582        self.extra.as_deref()
583    }
584    #[doc(hidden)]
585    fn client_id(&self) -> Option<i32> {
586        self.client_id
587    }
588}
589
590impl TDPassportElementErrorSource for PassportElementErrorSourceTranslationFiles {}
591
592impl PassportElementErrorSourceTranslationFiles {
593    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
594        Ok(serde_json::from_str(json.as_ref())?)
595    }
596    pub fn builder() -> PassportElementErrorSourceTranslationFilesBuilder {
597        let mut inner = PassportElementErrorSourceTranslationFiles::default();
598        inner.extra = Some(Uuid::new_v4().to_string());
599
600        PassportElementErrorSourceTranslationFilesBuilder { inner }
601    }
602}
603
604#[doc(hidden)]
605pub struct PassportElementErrorSourceTranslationFilesBuilder {
606    inner: PassportElementErrorSourceTranslationFiles,
607}
608
609#[deprecated]
610pub type RTDPassportElementErrorSourceTranslationFilesBuilder =
611    PassportElementErrorSourceTranslationFilesBuilder;
612
613impl PassportElementErrorSourceTranslationFilesBuilder {
614    pub fn build(&self) -> PassportElementErrorSourceTranslationFiles {
615        self.inner.clone()
616    }
617}
618
619impl AsRef<PassportElementErrorSourceTranslationFiles>
620    for PassportElementErrorSourceTranslationFiles
621{
622    fn as_ref(&self) -> &PassportElementErrorSourceTranslationFiles {
623        self
624    }
625}
626
627impl AsRef<PassportElementErrorSourceTranslationFiles>
628    for PassportElementErrorSourceTranslationFilesBuilder
629{
630    fn as_ref(&self) -> &PassportElementErrorSourceTranslationFiles {
631        &self.inner
632    }
633}
634
635/// The element contains an error in an unspecified place. The error will be considered resolved when new data is added
636#[derive(Debug, Clone, Default, Serialize, Deserialize)]
637pub struct PassportElementErrorSourceUnspecified {
638    #[doc(hidden)]
639    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
640    extra: Option<String>,
641    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
642    client_id: Option<i32>,
643}
644
645impl RObject for PassportElementErrorSourceUnspecified {
646    #[doc(hidden)]
647    fn extra(&self) -> Option<&str> {
648        self.extra.as_deref()
649    }
650    #[doc(hidden)]
651    fn client_id(&self) -> Option<i32> {
652        self.client_id
653    }
654}
655
656impl TDPassportElementErrorSource for PassportElementErrorSourceUnspecified {}
657
658impl PassportElementErrorSourceUnspecified {
659    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
660        Ok(serde_json::from_str(json.as_ref())?)
661    }
662    pub fn builder() -> PassportElementErrorSourceUnspecifiedBuilder {
663        let mut inner = PassportElementErrorSourceUnspecified::default();
664        inner.extra = Some(Uuid::new_v4().to_string());
665
666        PassportElementErrorSourceUnspecifiedBuilder { inner }
667    }
668}
669
670#[doc(hidden)]
671pub struct PassportElementErrorSourceUnspecifiedBuilder {
672    inner: PassportElementErrorSourceUnspecified,
673}
674
675#[deprecated]
676pub type RTDPassportElementErrorSourceUnspecifiedBuilder =
677    PassportElementErrorSourceUnspecifiedBuilder;
678
679impl PassportElementErrorSourceUnspecifiedBuilder {
680    pub fn build(&self) -> PassportElementErrorSourceUnspecified {
681        self.inner.clone()
682    }
683}
684
685impl AsRef<PassportElementErrorSourceUnspecified> for PassportElementErrorSourceUnspecified {
686    fn as_ref(&self) -> &PassportElementErrorSourceUnspecified {
687        self
688    }
689}
690
691impl AsRef<PassportElementErrorSourceUnspecified> for PassportElementErrorSourceUnspecifiedBuilder {
692    fn as_ref(&self) -> &PassportElementErrorSourceUnspecified {
693        &self.inner
694    }
695}
rust_tdlib/types/passport_element_error_source.rs

rust_tdlib/types/
passport_element_error_source.rs
