1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use crate::errors::Result;
use crate::types::*;
use uuid::Uuid;

/// Returns information about a file by its remote ID; this is an offline request. Can be used to register a URL as a file for further uploading, or sending as a message. Even the request succeeds, the file can be used only if it is still accessible to the user. For example, if the file is from a message, then the message must be not deleted and accessible to the user. If the file database is disabled, then the corresponding object with the file must be preloaded by the application
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetRemoteFile {
    #[doc(hidden)]
    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
    extra: Option<String>,
    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
    client_id: Option<i32>,
    /// Remote identifier of the file to get

    #[serde(default)]
    remote_file_id: String,
    /// File type; pass null if unknown

    #[serde(skip_serializing_if = "FileType::_is_default")]
    file_type: FileType,

    #[serde(rename(serialize = "@type"))]
    td_type: String,
}

impl RObject for GetRemoteFile {
    #[doc(hidden)]
    fn extra(&self) -> Option<&str> {
        self.extra.as_deref()
    }
    #[doc(hidden)]
    fn client_id(&self) -> Option<i32> {
        self.client_id
    }
}

impl RFunction for GetRemoteFile {}

impl GetRemoteFile {
    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
        Ok(serde_json::from_str(json.as_ref())?)
    }
    pub fn builder() -> GetRemoteFileBuilder {
        let mut inner = GetRemoteFile::default();
        inner.extra = Some(Uuid::new_v4().to_string());

        inner.td_type = "getRemoteFile".to_string();

        GetRemoteFileBuilder { inner }
    }

    pub fn remote_file_id(&self) -> &String {
        &self.remote_file_id
    }

    pub fn file_type(&self) -> &FileType {
        &self.file_type
    }
}

#[doc(hidden)]
pub struct GetRemoteFileBuilder {
    inner: GetRemoteFile,
}

#[deprecated]
pub type RTDGetRemoteFileBuilder = GetRemoteFileBuilder;

impl GetRemoteFileBuilder {
    pub fn build(&self) -> GetRemoteFile {
        self.inner.clone()
    }

    pub fn remote_file_id<T: AsRef<str>>(&mut self, remote_file_id: T) -> &mut Self {
        self.inner.remote_file_id = remote_file_id.as_ref().to_string();
        self
    }

    pub fn file_type<T: AsRef<FileType>>(&mut self, file_type: T) -> &mut Self {
        self.inner.file_type = file_type.as_ref().clone();
        self
    }
}

impl AsRef<GetRemoteFile> for GetRemoteFile {
    fn as_ref(&self) -> &GetRemoteFile {
        self
    }
}

impl AsRef<GetRemoteFile> for GetRemoteFileBuilder {
    fn as_ref(&self) -> &GetRemoteFile {
        &self.inner
    }
}