rust_tdlib/types/
file_type.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Represents the type of a file
8pub trait TDFileType: Debug + RObject {}
9
10/// Represents the type of a file
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum FileType {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// The file is an animation
18    #[serde(rename = "fileTypeAnimation")]
19    Animation(FileTypeAnimation),
20    /// The file is an audio file
21    #[serde(rename = "fileTypeAudio")]
22    Audio(FileTypeAudio),
23    /// The file is a document
24    #[serde(rename = "fileTypeDocument")]
25    Document(FileTypeDocument),
26    /// The data is not a file
27    #[serde(rename = "fileTypeNone")]
28    None(FileTypeNone),
29    /// The file is a photo
30    #[serde(rename = "fileTypePhoto")]
31    Photo(FileTypePhoto),
32    /// The file is a profile photo
33    #[serde(rename = "fileTypeProfilePhoto")]
34    ProfilePhoto(FileTypeProfilePhoto),
35    /// The file was sent to a secret chat (the file type is not known to the server)
36    #[serde(rename = "fileTypeSecret")]
37    Secret(FileTypeSecret),
38    /// The file is a thumbnail of a file from a secret chat
39    #[serde(rename = "fileTypeSecretThumbnail")]
40    SecretThumbnail(FileTypeSecretThumbnail),
41    /// The file is a file from Secure storage used for storing Telegram Passport files
42    #[serde(rename = "fileTypeSecure")]
43    Secure(FileTypeSecure),
44    /// The file is a sticker
45    #[serde(rename = "fileTypeSticker")]
46    Sticker(FileTypeSticker),
47    /// The file is a thumbnail of another file
48    #[serde(rename = "fileTypeThumbnail")]
49    Thumbnail(FileTypeThumbnail),
50    /// The file type is not yet known
51    #[serde(rename = "fileTypeUnknown")]
52    Unknown(FileTypeUnknown),
53    /// The file is a video
54    #[serde(rename = "fileTypeVideo")]
55    Video(FileTypeVideo),
56    /// The file is a video note
57    #[serde(rename = "fileTypeVideoNote")]
58    VideoNote(FileTypeVideoNote),
59    /// The file is a voice note
60    #[serde(rename = "fileTypeVoiceNote")]
61    VoiceNote(FileTypeVoiceNote),
62    /// The file is a wallpaper or a background pattern
63    #[serde(rename = "fileTypeWallpaper")]
64    Wallpaper(FileTypeWallpaper),
65}
66
67impl RObject for FileType {
68    #[doc(hidden)]
69    fn extra(&self) -> Option<&str> {
70        match self {
71            FileType::Animation(t) => t.extra(),
72            FileType::Audio(t) => t.extra(),
73            FileType::Document(t) => t.extra(),
74            FileType::None(t) => t.extra(),
75            FileType::Photo(t) => t.extra(),
76            FileType::ProfilePhoto(t) => t.extra(),
77            FileType::Secret(t) => t.extra(),
78            FileType::SecretThumbnail(t) => t.extra(),
79            FileType::Secure(t) => t.extra(),
80            FileType::Sticker(t) => t.extra(),
81            FileType::Thumbnail(t) => t.extra(),
82            FileType::Unknown(t) => t.extra(),
83            FileType::Video(t) => t.extra(),
84            FileType::VideoNote(t) => t.extra(),
85            FileType::VoiceNote(t) => t.extra(),
86            FileType::Wallpaper(t) => t.extra(),
87
88            _ => None,
89        }
90    }
91    #[doc(hidden)]
92    fn client_id(&self) -> Option<i32> {
93        match self {
94            FileType::Animation(t) => t.client_id(),
95            FileType::Audio(t) => t.client_id(),
96            FileType::Document(t) => t.client_id(),
97            FileType::None(t) => t.client_id(),
98            FileType::Photo(t) => t.client_id(),
99            FileType::ProfilePhoto(t) => t.client_id(),
100            FileType::Secret(t) => t.client_id(),
101            FileType::SecretThumbnail(t) => t.client_id(),
102            FileType::Secure(t) => t.client_id(),
103            FileType::Sticker(t) => t.client_id(),
104            FileType::Thumbnail(t) => t.client_id(),
105            FileType::Unknown(t) => t.client_id(),
106            FileType::Video(t) => t.client_id(),
107            FileType::VideoNote(t) => t.client_id(),
108            FileType::VoiceNote(t) => t.client_id(),
109            FileType::Wallpaper(t) => t.client_id(),
110
111            _ => None,
112        }
113    }
114}
115
116impl FileType {
117    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
118        Ok(serde_json::from_str(json.as_ref())?)
119    }
120    #[doc(hidden)]
121    pub fn _is_default(&self) -> bool {
122        matches!(self, FileType::_Default)
123    }
124}
125
126impl AsRef<FileType> for FileType {
127    fn as_ref(&self) -> &FileType {
128        self
129    }
130}
131
132/// The file is an animation
133#[derive(Debug, Clone, Default, Serialize, Deserialize)]
134pub struct FileTypeAnimation {
135    #[doc(hidden)]
136    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
137    extra: Option<String>,
138    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
139    client_id: Option<i32>,
140}
141
142impl RObject for FileTypeAnimation {
143    #[doc(hidden)]
144    fn extra(&self) -> Option<&str> {
145        self.extra.as_deref()
146    }
147    #[doc(hidden)]
148    fn client_id(&self) -> Option<i32> {
149        self.client_id
150    }
151}
152
153impl TDFileType for FileTypeAnimation {}
154
155impl FileTypeAnimation {
156    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
157        Ok(serde_json::from_str(json.as_ref())?)
158    }
159    pub fn builder() -> FileTypeAnimationBuilder {
160        let mut inner = FileTypeAnimation::default();
161        inner.extra = Some(Uuid::new_v4().to_string());
162
163        FileTypeAnimationBuilder { inner }
164    }
165}
166
167#[doc(hidden)]
168pub struct FileTypeAnimationBuilder {
169    inner: FileTypeAnimation,
170}
171
172#[deprecated]
173pub type RTDFileTypeAnimationBuilder = FileTypeAnimationBuilder;
174
175impl FileTypeAnimationBuilder {
176    pub fn build(&self) -> FileTypeAnimation {
177        self.inner.clone()
178    }
179}
180
181impl AsRef<FileTypeAnimation> for FileTypeAnimation {
182    fn as_ref(&self) -> &FileTypeAnimation {
183        self
184    }
185}
186
187impl AsRef<FileTypeAnimation> for FileTypeAnimationBuilder {
188    fn as_ref(&self) -> &FileTypeAnimation {
189        &self.inner
190    }
191}
192
193/// The file is an audio file
194#[derive(Debug, Clone, Default, Serialize, Deserialize)]
195pub struct FileTypeAudio {
196    #[doc(hidden)]
197    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
198    extra: Option<String>,
199    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
200    client_id: Option<i32>,
201}
202
203impl RObject for FileTypeAudio {
204    #[doc(hidden)]
205    fn extra(&self) -> Option<&str> {
206        self.extra.as_deref()
207    }
208    #[doc(hidden)]
209    fn client_id(&self) -> Option<i32> {
210        self.client_id
211    }
212}
213
214impl TDFileType for FileTypeAudio {}
215
216impl FileTypeAudio {
217    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
218        Ok(serde_json::from_str(json.as_ref())?)
219    }
220    pub fn builder() -> FileTypeAudioBuilder {
221        let mut inner = FileTypeAudio::default();
222        inner.extra = Some(Uuid::new_v4().to_string());
223
224        FileTypeAudioBuilder { inner }
225    }
226}
227
228#[doc(hidden)]
229pub struct FileTypeAudioBuilder {
230    inner: FileTypeAudio,
231}
232
233#[deprecated]
234pub type RTDFileTypeAudioBuilder = FileTypeAudioBuilder;
235
236impl FileTypeAudioBuilder {
237    pub fn build(&self) -> FileTypeAudio {
238        self.inner.clone()
239    }
240}
241
242impl AsRef<FileTypeAudio> for FileTypeAudio {
243    fn as_ref(&self) -> &FileTypeAudio {
244        self
245    }
246}
247
248impl AsRef<FileTypeAudio> for FileTypeAudioBuilder {
249    fn as_ref(&self) -> &FileTypeAudio {
250        &self.inner
251    }
252}
253
254/// The file is a document
255#[derive(Debug, Clone, Default, Serialize, Deserialize)]
256pub struct FileTypeDocument {
257    #[doc(hidden)]
258    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
259    extra: Option<String>,
260    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
261    client_id: Option<i32>,
262}
263
264impl RObject for FileTypeDocument {
265    #[doc(hidden)]
266    fn extra(&self) -> Option<&str> {
267        self.extra.as_deref()
268    }
269    #[doc(hidden)]
270    fn client_id(&self) -> Option<i32> {
271        self.client_id
272    }
273}
274
275impl TDFileType for FileTypeDocument {}
276
277impl FileTypeDocument {
278    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
279        Ok(serde_json::from_str(json.as_ref())?)
280    }
281    pub fn builder() -> FileTypeDocumentBuilder {
282        let mut inner = FileTypeDocument::default();
283        inner.extra = Some(Uuid::new_v4().to_string());
284
285        FileTypeDocumentBuilder { inner }
286    }
287}
288
289#[doc(hidden)]
290pub struct FileTypeDocumentBuilder {
291    inner: FileTypeDocument,
292}
293
294#[deprecated]
295pub type RTDFileTypeDocumentBuilder = FileTypeDocumentBuilder;
296
297impl FileTypeDocumentBuilder {
298    pub fn build(&self) -> FileTypeDocument {
299        self.inner.clone()
300    }
301}
302
303impl AsRef<FileTypeDocument> for FileTypeDocument {
304    fn as_ref(&self) -> &FileTypeDocument {
305        self
306    }
307}
308
309impl AsRef<FileTypeDocument> for FileTypeDocumentBuilder {
310    fn as_ref(&self) -> &FileTypeDocument {
311        &self.inner
312    }
313}
314
315/// The data is not a file
316#[derive(Debug, Clone, Default, Serialize, Deserialize)]
317pub struct FileTypeNone {
318    #[doc(hidden)]
319    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
320    extra: Option<String>,
321    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
322    client_id: Option<i32>,
323}
324
325impl RObject for FileTypeNone {
326    #[doc(hidden)]
327    fn extra(&self) -> Option<&str> {
328        self.extra.as_deref()
329    }
330    #[doc(hidden)]
331    fn client_id(&self) -> Option<i32> {
332        self.client_id
333    }
334}
335
336impl TDFileType for FileTypeNone {}
337
338impl FileTypeNone {
339    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
340        Ok(serde_json::from_str(json.as_ref())?)
341    }
342    pub fn builder() -> FileTypeNoneBuilder {
343        let mut inner = FileTypeNone::default();
344        inner.extra = Some(Uuid::new_v4().to_string());
345
346        FileTypeNoneBuilder { inner }
347    }
348}
349
350#[doc(hidden)]
351pub struct FileTypeNoneBuilder {
352    inner: FileTypeNone,
353}
354
355#[deprecated]
356pub type RTDFileTypeNoneBuilder = FileTypeNoneBuilder;
357
358impl FileTypeNoneBuilder {
359    pub fn build(&self) -> FileTypeNone {
360        self.inner.clone()
361    }
362}
363
364impl AsRef<FileTypeNone> for FileTypeNone {
365    fn as_ref(&self) -> &FileTypeNone {
366        self
367    }
368}
369
370impl AsRef<FileTypeNone> for FileTypeNoneBuilder {
371    fn as_ref(&self) -> &FileTypeNone {
372        &self.inner
373    }
374}
375
376/// The file is a photo
377#[derive(Debug, Clone, Default, Serialize, Deserialize)]
378pub struct FileTypePhoto {
379    #[doc(hidden)]
380    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
381    extra: Option<String>,
382    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
383    client_id: Option<i32>,
384}
385
386impl RObject for FileTypePhoto {
387    #[doc(hidden)]
388    fn extra(&self) -> Option<&str> {
389        self.extra.as_deref()
390    }
391    #[doc(hidden)]
392    fn client_id(&self) -> Option<i32> {
393        self.client_id
394    }
395}
396
397impl TDFileType for FileTypePhoto {}
398
399impl FileTypePhoto {
400    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
401        Ok(serde_json::from_str(json.as_ref())?)
402    }
403    pub fn builder() -> FileTypePhotoBuilder {
404        let mut inner = FileTypePhoto::default();
405        inner.extra = Some(Uuid::new_v4().to_string());
406
407        FileTypePhotoBuilder { inner }
408    }
409}
410
411#[doc(hidden)]
412pub struct FileTypePhotoBuilder {
413    inner: FileTypePhoto,
414}
415
416#[deprecated]
417pub type RTDFileTypePhotoBuilder = FileTypePhotoBuilder;
418
419impl FileTypePhotoBuilder {
420    pub fn build(&self) -> FileTypePhoto {
421        self.inner.clone()
422    }
423}
424
425impl AsRef<FileTypePhoto> for FileTypePhoto {
426    fn as_ref(&self) -> &FileTypePhoto {
427        self
428    }
429}
430
431impl AsRef<FileTypePhoto> for FileTypePhotoBuilder {
432    fn as_ref(&self) -> &FileTypePhoto {
433        &self.inner
434    }
435}
436
437/// The file is a profile photo
438#[derive(Debug, Clone, Default, Serialize, Deserialize)]
439pub struct FileTypeProfilePhoto {
440    #[doc(hidden)]
441    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
442    extra: Option<String>,
443    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
444    client_id: Option<i32>,
445}
446
447impl RObject for FileTypeProfilePhoto {
448    #[doc(hidden)]
449    fn extra(&self) -> Option<&str> {
450        self.extra.as_deref()
451    }
452    #[doc(hidden)]
453    fn client_id(&self) -> Option<i32> {
454        self.client_id
455    }
456}
457
458impl TDFileType for FileTypeProfilePhoto {}
459
460impl FileTypeProfilePhoto {
461    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
462        Ok(serde_json::from_str(json.as_ref())?)
463    }
464    pub fn builder() -> FileTypeProfilePhotoBuilder {
465        let mut inner = FileTypeProfilePhoto::default();
466        inner.extra = Some(Uuid::new_v4().to_string());
467
468        FileTypeProfilePhotoBuilder { inner }
469    }
470}
471
472#[doc(hidden)]
473pub struct FileTypeProfilePhotoBuilder {
474    inner: FileTypeProfilePhoto,
475}
476
477#[deprecated]
478pub type RTDFileTypeProfilePhotoBuilder = FileTypeProfilePhotoBuilder;
479
480impl FileTypeProfilePhotoBuilder {
481    pub fn build(&self) -> FileTypeProfilePhoto {
482        self.inner.clone()
483    }
484}
485
486impl AsRef<FileTypeProfilePhoto> for FileTypeProfilePhoto {
487    fn as_ref(&self) -> &FileTypeProfilePhoto {
488        self
489    }
490}
491
492impl AsRef<FileTypeProfilePhoto> for FileTypeProfilePhotoBuilder {
493    fn as_ref(&self) -> &FileTypeProfilePhoto {
494        &self.inner
495    }
496}
497
498/// The file was sent to a secret chat (the file type is not known to the server)
499#[derive(Debug, Clone, Default, Serialize, Deserialize)]
500pub struct FileTypeSecret {
501    #[doc(hidden)]
502    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
503    extra: Option<String>,
504    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
505    client_id: Option<i32>,
506}
507
508impl RObject for FileTypeSecret {
509    #[doc(hidden)]
510    fn extra(&self) -> Option<&str> {
511        self.extra.as_deref()
512    }
513    #[doc(hidden)]
514    fn client_id(&self) -> Option<i32> {
515        self.client_id
516    }
517}
518
519impl TDFileType for FileTypeSecret {}
520
521impl FileTypeSecret {
522    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
523        Ok(serde_json::from_str(json.as_ref())?)
524    }
525    pub fn builder() -> FileTypeSecretBuilder {
526        let mut inner = FileTypeSecret::default();
527        inner.extra = Some(Uuid::new_v4().to_string());
528
529        FileTypeSecretBuilder { inner }
530    }
531}
532
533#[doc(hidden)]
534pub struct FileTypeSecretBuilder {
535    inner: FileTypeSecret,
536}
537
538#[deprecated]
539pub type RTDFileTypeSecretBuilder = FileTypeSecretBuilder;
540
541impl FileTypeSecretBuilder {
542    pub fn build(&self) -> FileTypeSecret {
543        self.inner.clone()
544    }
545}
546
547impl AsRef<FileTypeSecret> for FileTypeSecret {
548    fn as_ref(&self) -> &FileTypeSecret {
549        self
550    }
551}
552
553impl AsRef<FileTypeSecret> for FileTypeSecretBuilder {
554    fn as_ref(&self) -> &FileTypeSecret {
555        &self.inner
556    }
557}
558
559/// The file is a thumbnail of a file from a secret chat
560#[derive(Debug, Clone, Default, Serialize, Deserialize)]
561pub struct FileTypeSecretThumbnail {
562    #[doc(hidden)]
563    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
564    extra: Option<String>,
565    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
566    client_id: Option<i32>,
567}
568
569impl RObject for FileTypeSecretThumbnail {
570    #[doc(hidden)]
571    fn extra(&self) -> Option<&str> {
572        self.extra.as_deref()
573    }
574    #[doc(hidden)]
575    fn client_id(&self) -> Option<i32> {
576        self.client_id
577    }
578}
579
580impl TDFileType for FileTypeSecretThumbnail {}
581
582impl FileTypeSecretThumbnail {
583    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
584        Ok(serde_json::from_str(json.as_ref())?)
585    }
586    pub fn builder() -> FileTypeSecretThumbnailBuilder {
587        let mut inner = FileTypeSecretThumbnail::default();
588        inner.extra = Some(Uuid::new_v4().to_string());
589
590        FileTypeSecretThumbnailBuilder { inner }
591    }
592}
593
594#[doc(hidden)]
595pub struct FileTypeSecretThumbnailBuilder {
596    inner: FileTypeSecretThumbnail,
597}
598
599#[deprecated]
600pub type RTDFileTypeSecretThumbnailBuilder = FileTypeSecretThumbnailBuilder;
601
602impl FileTypeSecretThumbnailBuilder {
603    pub fn build(&self) -> FileTypeSecretThumbnail {
604        self.inner.clone()
605    }
606}
607
608impl AsRef<FileTypeSecretThumbnail> for FileTypeSecretThumbnail {
609    fn as_ref(&self) -> &FileTypeSecretThumbnail {
610        self
611    }
612}
613
614impl AsRef<FileTypeSecretThumbnail> for FileTypeSecretThumbnailBuilder {
615    fn as_ref(&self) -> &FileTypeSecretThumbnail {
616        &self.inner
617    }
618}
619
620/// The file is a file from Secure storage used for storing Telegram Passport files
621#[derive(Debug, Clone, Default, Serialize, Deserialize)]
622pub struct FileTypeSecure {
623    #[doc(hidden)]
624    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
625    extra: Option<String>,
626    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
627    client_id: Option<i32>,
628}
629
630impl RObject for FileTypeSecure {
631    #[doc(hidden)]
632    fn extra(&self) -> Option<&str> {
633        self.extra.as_deref()
634    }
635    #[doc(hidden)]
636    fn client_id(&self) -> Option<i32> {
637        self.client_id
638    }
639}
640
641impl TDFileType for FileTypeSecure {}
642
643impl FileTypeSecure {
644    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
645        Ok(serde_json::from_str(json.as_ref())?)
646    }
647    pub fn builder() -> FileTypeSecureBuilder {
648        let mut inner = FileTypeSecure::default();
649        inner.extra = Some(Uuid::new_v4().to_string());
650
651        FileTypeSecureBuilder { inner }
652    }
653}
654
655#[doc(hidden)]
656pub struct FileTypeSecureBuilder {
657    inner: FileTypeSecure,
658}
659
660#[deprecated]
661pub type RTDFileTypeSecureBuilder = FileTypeSecureBuilder;
662
663impl FileTypeSecureBuilder {
664    pub fn build(&self) -> FileTypeSecure {
665        self.inner.clone()
666    }
667}
668
669impl AsRef<FileTypeSecure> for FileTypeSecure {
670    fn as_ref(&self) -> &FileTypeSecure {
671        self
672    }
673}
674
675impl AsRef<FileTypeSecure> for FileTypeSecureBuilder {
676    fn as_ref(&self) -> &FileTypeSecure {
677        &self.inner
678    }
679}
680
681/// The file is a sticker
682#[derive(Debug, Clone, Default, Serialize, Deserialize)]
683pub struct FileTypeSticker {
684    #[doc(hidden)]
685    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
686    extra: Option<String>,
687    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
688    client_id: Option<i32>,
689}
690
691impl RObject for FileTypeSticker {
692    #[doc(hidden)]
693    fn extra(&self) -> Option<&str> {
694        self.extra.as_deref()
695    }
696    #[doc(hidden)]
697    fn client_id(&self) -> Option<i32> {
698        self.client_id
699    }
700}
701
702impl TDFileType for FileTypeSticker {}
703
704impl FileTypeSticker {
705    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
706        Ok(serde_json::from_str(json.as_ref())?)
707    }
708    pub fn builder() -> FileTypeStickerBuilder {
709        let mut inner = FileTypeSticker::default();
710        inner.extra = Some(Uuid::new_v4().to_string());
711
712        FileTypeStickerBuilder { inner }
713    }
714}
715
716#[doc(hidden)]
717pub struct FileTypeStickerBuilder {
718    inner: FileTypeSticker,
719}
720
721#[deprecated]
722pub type RTDFileTypeStickerBuilder = FileTypeStickerBuilder;
723
724impl FileTypeStickerBuilder {
725    pub fn build(&self) -> FileTypeSticker {
726        self.inner.clone()
727    }
728}
729
730impl AsRef<FileTypeSticker> for FileTypeSticker {
731    fn as_ref(&self) -> &FileTypeSticker {
732        self
733    }
734}
735
736impl AsRef<FileTypeSticker> for FileTypeStickerBuilder {
737    fn as_ref(&self) -> &FileTypeSticker {
738        &self.inner
739    }
740}
741
742/// The file is a thumbnail of another file
743#[derive(Debug, Clone, Default, Serialize, Deserialize)]
744pub struct FileTypeThumbnail {
745    #[doc(hidden)]
746    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
747    extra: Option<String>,
748    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
749    client_id: Option<i32>,
750}
751
752impl RObject for FileTypeThumbnail {
753    #[doc(hidden)]
754    fn extra(&self) -> Option<&str> {
755        self.extra.as_deref()
756    }
757    #[doc(hidden)]
758    fn client_id(&self) -> Option<i32> {
759        self.client_id
760    }
761}
762
763impl TDFileType for FileTypeThumbnail {}
764
765impl FileTypeThumbnail {
766    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
767        Ok(serde_json::from_str(json.as_ref())?)
768    }
769    pub fn builder() -> FileTypeThumbnailBuilder {
770        let mut inner = FileTypeThumbnail::default();
771        inner.extra = Some(Uuid::new_v4().to_string());
772
773        FileTypeThumbnailBuilder { inner }
774    }
775}
776
777#[doc(hidden)]
778pub struct FileTypeThumbnailBuilder {
779    inner: FileTypeThumbnail,
780}
781
782#[deprecated]
783pub type RTDFileTypeThumbnailBuilder = FileTypeThumbnailBuilder;
784
785impl FileTypeThumbnailBuilder {
786    pub fn build(&self) -> FileTypeThumbnail {
787        self.inner.clone()
788    }
789}
790
791impl AsRef<FileTypeThumbnail> for FileTypeThumbnail {
792    fn as_ref(&self) -> &FileTypeThumbnail {
793        self
794    }
795}
796
797impl AsRef<FileTypeThumbnail> for FileTypeThumbnailBuilder {
798    fn as_ref(&self) -> &FileTypeThumbnail {
799        &self.inner
800    }
801}
802
803/// The file type is not yet known
804#[derive(Debug, Clone, Default, Serialize, Deserialize)]
805pub struct FileTypeUnknown {
806    #[doc(hidden)]
807    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
808    extra: Option<String>,
809    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
810    client_id: Option<i32>,
811}
812
813impl RObject for FileTypeUnknown {
814    #[doc(hidden)]
815    fn extra(&self) -> Option<&str> {
816        self.extra.as_deref()
817    }
818    #[doc(hidden)]
819    fn client_id(&self) -> Option<i32> {
820        self.client_id
821    }
822}
823
824impl TDFileType for FileTypeUnknown {}
825
826impl FileTypeUnknown {
827    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
828        Ok(serde_json::from_str(json.as_ref())?)
829    }
830    pub fn builder() -> FileTypeUnknownBuilder {
831        let mut inner = FileTypeUnknown::default();
832        inner.extra = Some(Uuid::new_v4().to_string());
833
834        FileTypeUnknownBuilder { inner }
835    }
836}
837
838#[doc(hidden)]
839pub struct FileTypeUnknownBuilder {
840    inner: FileTypeUnknown,
841}
842
843#[deprecated]
844pub type RTDFileTypeUnknownBuilder = FileTypeUnknownBuilder;
845
846impl FileTypeUnknownBuilder {
847    pub fn build(&self) -> FileTypeUnknown {
848        self.inner.clone()
849    }
850}
851
852impl AsRef<FileTypeUnknown> for FileTypeUnknown {
853    fn as_ref(&self) -> &FileTypeUnknown {
854        self
855    }
856}
857
858impl AsRef<FileTypeUnknown> for FileTypeUnknownBuilder {
859    fn as_ref(&self) -> &FileTypeUnknown {
860        &self.inner
861    }
862}
863
864/// The file is a video
865#[derive(Debug, Clone, Default, Serialize, Deserialize)]
866pub struct FileTypeVideo {
867    #[doc(hidden)]
868    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
869    extra: Option<String>,
870    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
871    client_id: Option<i32>,
872}
873
874impl RObject for FileTypeVideo {
875    #[doc(hidden)]
876    fn extra(&self) -> Option<&str> {
877        self.extra.as_deref()
878    }
879    #[doc(hidden)]
880    fn client_id(&self) -> Option<i32> {
881        self.client_id
882    }
883}
884
885impl TDFileType for FileTypeVideo {}
886
887impl FileTypeVideo {
888    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
889        Ok(serde_json::from_str(json.as_ref())?)
890    }
891    pub fn builder() -> FileTypeVideoBuilder {
892        let mut inner = FileTypeVideo::default();
893        inner.extra = Some(Uuid::new_v4().to_string());
894
895        FileTypeVideoBuilder { inner }
896    }
897}
898
899#[doc(hidden)]
900pub struct FileTypeVideoBuilder {
901    inner: FileTypeVideo,
902}
903
904#[deprecated]
905pub type RTDFileTypeVideoBuilder = FileTypeVideoBuilder;
906
907impl FileTypeVideoBuilder {
908    pub fn build(&self) -> FileTypeVideo {
909        self.inner.clone()
910    }
911}
912
913impl AsRef<FileTypeVideo> for FileTypeVideo {
914    fn as_ref(&self) -> &FileTypeVideo {
915        self
916    }
917}
918
919impl AsRef<FileTypeVideo> for FileTypeVideoBuilder {
920    fn as_ref(&self) -> &FileTypeVideo {
921        &self.inner
922    }
923}
924
925/// The file is a video note
926#[derive(Debug, Clone, Default, Serialize, Deserialize)]
927pub struct FileTypeVideoNote {
928    #[doc(hidden)]
929    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
930    extra: Option<String>,
931    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
932    client_id: Option<i32>,
933}
934
935impl RObject for FileTypeVideoNote {
936    #[doc(hidden)]
937    fn extra(&self) -> Option<&str> {
938        self.extra.as_deref()
939    }
940    #[doc(hidden)]
941    fn client_id(&self) -> Option<i32> {
942        self.client_id
943    }
944}
945
946impl TDFileType for FileTypeVideoNote {}
947
948impl FileTypeVideoNote {
949    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
950        Ok(serde_json::from_str(json.as_ref())?)
951    }
952    pub fn builder() -> FileTypeVideoNoteBuilder {
953        let mut inner = FileTypeVideoNote::default();
954        inner.extra = Some(Uuid::new_v4().to_string());
955
956        FileTypeVideoNoteBuilder { inner }
957    }
958}
959
960#[doc(hidden)]
961pub struct FileTypeVideoNoteBuilder {
962    inner: FileTypeVideoNote,
963}
964
965#[deprecated]
966pub type RTDFileTypeVideoNoteBuilder = FileTypeVideoNoteBuilder;
967
968impl FileTypeVideoNoteBuilder {
969    pub fn build(&self) -> FileTypeVideoNote {
970        self.inner.clone()
971    }
972}
973
974impl AsRef<FileTypeVideoNote> for FileTypeVideoNote {
975    fn as_ref(&self) -> &FileTypeVideoNote {
976        self
977    }
978}
979
980impl AsRef<FileTypeVideoNote> for FileTypeVideoNoteBuilder {
981    fn as_ref(&self) -> &FileTypeVideoNote {
982        &self.inner
983    }
984}
985
986/// The file is a voice note
987#[derive(Debug, Clone, Default, Serialize, Deserialize)]
988pub struct FileTypeVoiceNote {
989    #[doc(hidden)]
990    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
991    extra: Option<String>,
992    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
993    client_id: Option<i32>,
994}
995
996impl RObject for FileTypeVoiceNote {
997    #[doc(hidden)]
998    fn extra(&self) -> Option<&str> {
999        self.extra.as_deref()
1000    }
1001    #[doc(hidden)]
1002    fn client_id(&self) -> Option<i32> {
1003        self.client_id
1004    }
1005}
1006
1007impl TDFileType for FileTypeVoiceNote {}
1008
1009impl FileTypeVoiceNote {
1010    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1011        Ok(serde_json::from_str(json.as_ref())?)
1012    }
1013    pub fn builder() -> FileTypeVoiceNoteBuilder {
1014        let mut inner = FileTypeVoiceNote::default();
1015        inner.extra = Some(Uuid::new_v4().to_string());
1016
1017        FileTypeVoiceNoteBuilder { inner }
1018    }
1019}
1020
1021#[doc(hidden)]
1022pub struct FileTypeVoiceNoteBuilder {
1023    inner: FileTypeVoiceNote,
1024}
1025
1026#[deprecated]
1027pub type RTDFileTypeVoiceNoteBuilder = FileTypeVoiceNoteBuilder;
1028
1029impl FileTypeVoiceNoteBuilder {
1030    pub fn build(&self) -> FileTypeVoiceNote {
1031        self.inner.clone()
1032    }
1033}
1034
1035impl AsRef<FileTypeVoiceNote> for FileTypeVoiceNote {
1036    fn as_ref(&self) -> &FileTypeVoiceNote {
1037        self
1038    }
1039}
1040
1041impl AsRef<FileTypeVoiceNote> for FileTypeVoiceNoteBuilder {
1042    fn as_ref(&self) -> &FileTypeVoiceNote {
1043        &self.inner
1044    }
1045}
1046
1047/// The file is a wallpaper or a background pattern
1048#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1049pub struct FileTypeWallpaper {
1050    #[doc(hidden)]
1051    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1052    extra: Option<String>,
1053    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
1054    client_id: Option<i32>,
1055}
1056
1057impl RObject for FileTypeWallpaper {
1058    #[doc(hidden)]
1059    fn extra(&self) -> Option<&str> {
1060        self.extra.as_deref()
1061    }
1062    #[doc(hidden)]
1063    fn client_id(&self) -> Option<i32> {
1064        self.client_id
1065    }
1066}
1067
1068impl TDFileType for FileTypeWallpaper {}
1069
1070impl FileTypeWallpaper {
1071    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1072        Ok(serde_json::from_str(json.as_ref())?)
1073    }
1074    pub fn builder() -> FileTypeWallpaperBuilder {
1075        let mut inner = FileTypeWallpaper::default();
1076        inner.extra = Some(Uuid::new_v4().to_string());
1077
1078        FileTypeWallpaperBuilder { inner }
1079    }
1080}
1081
1082#[doc(hidden)]
1083pub struct FileTypeWallpaperBuilder {
1084    inner: FileTypeWallpaper,
1085}
1086
1087#[deprecated]
1088pub type RTDFileTypeWallpaperBuilder = FileTypeWallpaperBuilder;
1089
1090impl FileTypeWallpaperBuilder {
1091    pub fn build(&self) -> FileTypeWallpaper {
1092        self.inner.clone()
1093    }
1094}
1095
1096impl AsRef<FileTypeWallpaper> for FileTypeWallpaper {
1097    fn as_ref(&self) -> &FileTypeWallpaper {
1098        self
1099    }
1100}
1101
1102impl AsRef<FileTypeWallpaper> for FileTypeWallpaperBuilder {
1103    fn as_ref(&self) -> &FileTypeWallpaper {
1104        &self.inner
1105    }
1106}
rust_tdlib/types/file_type.rs

rust_tdlib/types/
file_type.rs
