rtdlib/types/
text_entity_type.rs

1
2use crate::types::*;
3use crate::errors::*;
4use uuid::Uuid;
5
6
7
8
9use std::fmt::Debug;
10use serde::de::{Deserialize, Deserializer};
11
12
13
14/// TRAIT | Represents a part of the text which must be formatted differently
15pub trait TDTextEntityType: Debug + RObject {}
16
17/// Represents a part of the text which must be formatted differently
18#[derive(Debug, Clone, Serialize)]
19#[serde(untagged)]
20pub enum TextEntityType {
21  #[doc(hidden)] _Default(()),
22  /// A bank card number. The getBankCardInfo method can be used to get information about the bank card
23  BankCardNumber(TextEntityTypeBankCardNumber),
24  /// A bold text
25  Bold(TextEntityTypeBold),
26  /// A bot command, beginning with "/"
27  BotCommand(TextEntityTypeBotCommand),
28  /// A cashtag text, beginning with "$" and consisting of capital English letters (e.g., "$USD")
29  Cashtag(TextEntityTypeCashtag),
30  /// Text that must be formatted as if inside a code HTML tag
31  Code(TextEntityTypeCode),
32  /// An email address
33  EmailAddress(TextEntityTypeEmailAddress),
34  /// A hashtag text, beginning with "#"
35  Hashtag(TextEntityTypeHashtag),
36  /// An italic text
37  Italic(TextEntityTypeItalic),
38  /// A media timestamp
39  MediaTimestamp(TextEntityTypeMediaTimestamp),
40  /// A mention of a user by their username
41  Mention(TextEntityTypeMention),
42  /// A text shows instead of a raw mention of the user (e.g., when the user has no username)
43  MentionName(TextEntityTypeMentionName),
44  /// A phone number
45  PhoneNumber(TextEntityTypePhoneNumber),
46  /// Text that must be formatted as if inside a pre HTML tag
47  Pre(TextEntityTypePre),
48  /// Text that must be formatted as if inside pre, and code HTML tags
49  PreCode(TextEntityTypePreCode),
50  /// A strikethrough text
51  Strikethrough(TextEntityTypeStrikethrough),
52  /// A text description shown instead of a raw URL
53  TextUrl(TextEntityTypeTextUrl),
54  /// An underlined text
55  Underline(TextEntityTypeUnderline),
56  /// An HTTP URL
57  Url(TextEntityTypeUrl),
58
59}
60
61impl Default for TextEntityType {
62  fn default() -> Self { TextEntityType::_Default(()) }
63}
64
65impl<'de> Deserialize<'de> for TextEntityType {
66  fn deserialize<D>(deserializer: D) -> Result<TextEntityType, D::Error> where D: Deserializer<'de> {
67    use serde::de::Error;
68    rtd_enum_deserialize!(
69      TextEntityType,
70      (textEntityTypeBankCardNumber, BankCardNumber);
71      (textEntityTypeBold, Bold);
72      (textEntityTypeBotCommand, BotCommand);
73      (textEntityTypeCashtag, Cashtag);
74      (textEntityTypeCode, Code);
75      (textEntityTypeEmailAddress, EmailAddress);
76      (textEntityTypeHashtag, Hashtag);
77      (textEntityTypeItalic, Italic);
78      (textEntityTypeMediaTimestamp, MediaTimestamp);
79      (textEntityTypeMention, Mention);
80      (textEntityTypeMentionName, MentionName);
81      (textEntityTypePhoneNumber, PhoneNumber);
82      (textEntityTypePre, Pre);
83      (textEntityTypePreCode, PreCode);
84      (textEntityTypeStrikethrough, Strikethrough);
85      (textEntityTypeTextUrl, TextUrl);
86      (textEntityTypeUnderline, Underline);
87      (textEntityTypeUrl, Url);
88
89    )(deserializer)
90  }
91}
92
93impl RObject for TextEntityType {
94  #[doc(hidden)] fn td_name(&self) -> &'static str {
95    match self {
96      TextEntityType::BankCardNumber(t) => t.td_name(),
97      TextEntityType::Bold(t) => t.td_name(),
98      TextEntityType::BotCommand(t) => t.td_name(),
99      TextEntityType::Cashtag(t) => t.td_name(),
100      TextEntityType::Code(t) => t.td_name(),
101      TextEntityType::EmailAddress(t) => t.td_name(),
102      TextEntityType::Hashtag(t) => t.td_name(),
103      TextEntityType::Italic(t) => t.td_name(),
104      TextEntityType::MediaTimestamp(t) => t.td_name(),
105      TextEntityType::Mention(t) => t.td_name(),
106      TextEntityType::MentionName(t) => t.td_name(),
107      TextEntityType::PhoneNumber(t) => t.td_name(),
108      TextEntityType::Pre(t) => t.td_name(),
109      TextEntityType::PreCode(t) => t.td_name(),
110      TextEntityType::Strikethrough(t) => t.td_name(),
111      TextEntityType::TextUrl(t) => t.td_name(),
112      TextEntityType::Underline(t) => t.td_name(),
113      TextEntityType::Url(t) => t.td_name(),
114
115      _ => "-1",
116    }
117  }
118  #[doc(hidden)] fn extra(&self) -> Option<String> {
119    match self {
120      TextEntityType::BankCardNumber(t) => t.extra(),
121      TextEntityType::Bold(t) => t.extra(),
122      TextEntityType::BotCommand(t) => t.extra(),
123      TextEntityType::Cashtag(t) => t.extra(),
124      TextEntityType::Code(t) => t.extra(),
125      TextEntityType::EmailAddress(t) => t.extra(),
126      TextEntityType::Hashtag(t) => t.extra(),
127      TextEntityType::Italic(t) => t.extra(),
128      TextEntityType::MediaTimestamp(t) => t.extra(),
129      TextEntityType::Mention(t) => t.extra(),
130      TextEntityType::MentionName(t) => t.extra(),
131      TextEntityType::PhoneNumber(t) => t.extra(),
132      TextEntityType::Pre(t) => t.extra(),
133      TextEntityType::PreCode(t) => t.extra(),
134      TextEntityType::Strikethrough(t) => t.extra(),
135      TextEntityType::TextUrl(t) => t.extra(),
136      TextEntityType::Underline(t) => t.extra(),
137      TextEntityType::Url(t) => t.extra(),
138
139      _ => None,
140    }
141  }
142  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
143}
144
145impl TextEntityType {
146  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
147  #[doc(hidden)] pub fn _is_default(&self) -> bool { if let TextEntityType::_Default(_) = self { true } else { false } }
148
149  pub fn is_bank_card_number(&self) -> bool { if let TextEntityType::BankCardNumber(_) = self { true } else { false } }
150  pub fn is_bold(&self) -> bool { if let TextEntityType::Bold(_) = self { true } else { false } }
151  pub fn is_bot_command(&self) -> bool { if let TextEntityType::BotCommand(_) = self { true } else { false } }
152  pub fn is_cashtag(&self) -> bool { if let TextEntityType::Cashtag(_) = self { true } else { false } }
153  pub fn is_code(&self) -> bool { if let TextEntityType::Code(_) = self { true } else { false } }
154  pub fn is_email_address(&self) -> bool { if let TextEntityType::EmailAddress(_) = self { true } else { false } }
155  pub fn is_hashtag(&self) -> bool { if let TextEntityType::Hashtag(_) = self { true } else { false } }
156  pub fn is_italic(&self) -> bool { if let TextEntityType::Italic(_) = self { true } else { false } }
157  pub fn is_media_timestamp(&self) -> bool { if let TextEntityType::MediaTimestamp(_) = self { true } else { false } }
158  pub fn is_mention(&self) -> bool { if let TextEntityType::Mention(_) = self { true } else { false } }
159  pub fn is_mention_name(&self) -> bool { if let TextEntityType::MentionName(_) = self { true } else { false } }
160  pub fn is_phone_number(&self) -> bool { if let TextEntityType::PhoneNumber(_) = self { true } else { false } }
161  pub fn is_pre(&self) -> bool { if let TextEntityType::Pre(_) = self { true } else { false } }
162  pub fn is_pre_code(&self) -> bool { if let TextEntityType::PreCode(_) = self { true } else { false } }
163  pub fn is_strikethrough(&self) -> bool { if let TextEntityType::Strikethrough(_) = self { true } else { false } }
164  pub fn is_text_url(&self) -> bool { if let TextEntityType::TextUrl(_) = self { true } else { false } }
165  pub fn is_underline(&self) -> bool { if let TextEntityType::Underline(_) = self { true } else { false } }
166  pub fn is_url(&self) -> bool { if let TextEntityType::Url(_) = self { true } else { false } }
167
168  pub fn on_bank_card_number<F: FnOnce(&TextEntityTypeBankCardNumber)>(&self, fnc: F) -> &Self { if let TextEntityType::BankCardNumber(t) = self { fnc(t) }; self }
169  pub fn on_bold<F: FnOnce(&TextEntityTypeBold)>(&self, fnc: F) -> &Self { if let TextEntityType::Bold(t) = self { fnc(t) }; self }
170  pub fn on_bot_command<F: FnOnce(&TextEntityTypeBotCommand)>(&self, fnc: F) -> &Self { if let TextEntityType::BotCommand(t) = self { fnc(t) }; self }
171  pub fn on_cashtag<F: FnOnce(&TextEntityTypeCashtag)>(&self, fnc: F) -> &Self { if let TextEntityType::Cashtag(t) = self { fnc(t) }; self }
172  pub fn on_code<F: FnOnce(&TextEntityTypeCode)>(&self, fnc: F) -> &Self { if let TextEntityType::Code(t) = self { fnc(t) }; self }
173  pub fn on_email_address<F: FnOnce(&TextEntityTypeEmailAddress)>(&self, fnc: F) -> &Self { if let TextEntityType::EmailAddress(t) = self { fnc(t) }; self }
174  pub fn on_hashtag<F: FnOnce(&TextEntityTypeHashtag)>(&self, fnc: F) -> &Self { if let TextEntityType::Hashtag(t) = self { fnc(t) }; self }
175  pub fn on_italic<F: FnOnce(&TextEntityTypeItalic)>(&self, fnc: F) -> &Self { if let TextEntityType::Italic(t) = self { fnc(t) }; self }
176  pub fn on_media_timestamp<F: FnOnce(&TextEntityTypeMediaTimestamp)>(&self, fnc: F) -> &Self { if let TextEntityType::MediaTimestamp(t) = self { fnc(t) }; self }
177  pub fn on_mention<F: FnOnce(&TextEntityTypeMention)>(&self, fnc: F) -> &Self { if let TextEntityType::Mention(t) = self { fnc(t) }; self }
178  pub fn on_mention_name<F: FnOnce(&TextEntityTypeMentionName)>(&self, fnc: F) -> &Self { if let TextEntityType::MentionName(t) = self { fnc(t) }; self }
179  pub fn on_phone_number<F: FnOnce(&TextEntityTypePhoneNumber)>(&self, fnc: F) -> &Self { if let TextEntityType::PhoneNumber(t) = self { fnc(t) }; self }
180  pub fn on_pre<F: FnOnce(&TextEntityTypePre)>(&self, fnc: F) -> &Self { if let TextEntityType::Pre(t) = self { fnc(t) }; self }
181  pub fn on_pre_code<F: FnOnce(&TextEntityTypePreCode)>(&self, fnc: F) -> &Self { if let TextEntityType::PreCode(t) = self { fnc(t) }; self }
182  pub fn on_strikethrough<F: FnOnce(&TextEntityTypeStrikethrough)>(&self, fnc: F) -> &Self { if let TextEntityType::Strikethrough(t) = self { fnc(t) }; self }
183  pub fn on_text_url<F: FnOnce(&TextEntityTypeTextUrl)>(&self, fnc: F) -> &Self { if let TextEntityType::TextUrl(t) = self { fnc(t) }; self }
184  pub fn on_underline<F: FnOnce(&TextEntityTypeUnderline)>(&self, fnc: F) -> &Self { if let TextEntityType::Underline(t) = self { fnc(t) }; self }
185  pub fn on_url<F: FnOnce(&TextEntityTypeUrl)>(&self, fnc: F) -> &Self { if let TextEntityType::Url(t) = self { fnc(t) }; self }
186
187  pub fn as_bank_card_number(&self) -> Option<&TextEntityTypeBankCardNumber> { if let TextEntityType::BankCardNumber(t) = self { return Some(t) } None }
188  pub fn as_bold(&self) -> Option<&TextEntityTypeBold> { if let TextEntityType::Bold(t) = self { return Some(t) } None }
189  pub fn as_bot_command(&self) -> Option<&TextEntityTypeBotCommand> { if let TextEntityType::BotCommand(t) = self { return Some(t) } None }
190  pub fn as_cashtag(&self) -> Option<&TextEntityTypeCashtag> { if let TextEntityType::Cashtag(t) = self { return Some(t) } None }
191  pub fn as_code(&self) -> Option<&TextEntityTypeCode> { if let TextEntityType::Code(t) = self { return Some(t) } None }
192  pub fn as_email_address(&self) -> Option<&TextEntityTypeEmailAddress> { if let TextEntityType::EmailAddress(t) = self { return Some(t) } None }
193  pub fn as_hashtag(&self) -> Option<&TextEntityTypeHashtag> { if let TextEntityType::Hashtag(t) = self { return Some(t) } None }
194  pub fn as_italic(&self) -> Option<&TextEntityTypeItalic> { if let TextEntityType::Italic(t) = self { return Some(t) } None }
195  pub fn as_media_timestamp(&self) -> Option<&TextEntityTypeMediaTimestamp> { if let TextEntityType::MediaTimestamp(t) = self { return Some(t) } None }
196  pub fn as_mention(&self) -> Option<&TextEntityTypeMention> { if let TextEntityType::Mention(t) = self { return Some(t) } None }
197  pub fn as_mention_name(&self) -> Option<&TextEntityTypeMentionName> { if let TextEntityType::MentionName(t) = self { return Some(t) } None }
198  pub fn as_phone_number(&self) -> Option<&TextEntityTypePhoneNumber> { if let TextEntityType::PhoneNumber(t) = self { return Some(t) } None }
199  pub fn as_pre(&self) -> Option<&TextEntityTypePre> { if let TextEntityType::Pre(t) = self { return Some(t) } None }
200  pub fn as_pre_code(&self) -> Option<&TextEntityTypePreCode> { if let TextEntityType::PreCode(t) = self { return Some(t) } None }
201  pub fn as_strikethrough(&self) -> Option<&TextEntityTypeStrikethrough> { if let TextEntityType::Strikethrough(t) = self { return Some(t) } None }
202  pub fn as_text_url(&self) -> Option<&TextEntityTypeTextUrl> { if let TextEntityType::TextUrl(t) = self { return Some(t) } None }
203  pub fn as_underline(&self) -> Option<&TextEntityTypeUnderline> { if let TextEntityType::Underline(t) = self { return Some(t) } None }
204  pub fn as_url(&self) -> Option<&TextEntityTypeUrl> { if let TextEntityType::Url(t) = self { return Some(t) } None }
205
206
207
208  pub fn bank_card_number<T: AsRef<TextEntityTypeBankCardNumber>>(t: T) -> Self { TextEntityType::BankCardNumber(t.as_ref().clone()) }
209
210  pub fn bold<T: AsRef<TextEntityTypeBold>>(t: T) -> Self { TextEntityType::Bold(t.as_ref().clone()) }
211
212  pub fn bot_command<T: AsRef<TextEntityTypeBotCommand>>(t: T) -> Self { TextEntityType::BotCommand(t.as_ref().clone()) }
213
214  pub fn cashtag<T: AsRef<TextEntityTypeCashtag>>(t: T) -> Self { TextEntityType::Cashtag(t.as_ref().clone()) }
215
216  pub fn code<T: AsRef<TextEntityTypeCode>>(t: T) -> Self { TextEntityType::Code(t.as_ref().clone()) }
217
218  pub fn email_address<T: AsRef<TextEntityTypeEmailAddress>>(t: T) -> Self { TextEntityType::EmailAddress(t.as_ref().clone()) }
219
220  pub fn hashtag<T: AsRef<TextEntityTypeHashtag>>(t: T) -> Self { TextEntityType::Hashtag(t.as_ref().clone()) }
221
222  pub fn italic<T: AsRef<TextEntityTypeItalic>>(t: T) -> Self { TextEntityType::Italic(t.as_ref().clone()) }
223
224  pub fn media_timestamp<T: AsRef<TextEntityTypeMediaTimestamp>>(t: T) -> Self { TextEntityType::MediaTimestamp(t.as_ref().clone()) }
225
226  pub fn mention<T: AsRef<TextEntityTypeMention>>(t: T) -> Self { TextEntityType::Mention(t.as_ref().clone()) }
227
228  pub fn mention_name<T: AsRef<TextEntityTypeMentionName>>(t: T) -> Self { TextEntityType::MentionName(t.as_ref().clone()) }
229
230  pub fn phone_number<T: AsRef<TextEntityTypePhoneNumber>>(t: T) -> Self { TextEntityType::PhoneNumber(t.as_ref().clone()) }
231
232  pub fn pre<T: AsRef<TextEntityTypePre>>(t: T) -> Self { TextEntityType::Pre(t.as_ref().clone()) }
233
234  pub fn pre_code<T: AsRef<TextEntityTypePreCode>>(t: T) -> Self { TextEntityType::PreCode(t.as_ref().clone()) }
235
236  pub fn strikethrough<T: AsRef<TextEntityTypeStrikethrough>>(t: T) -> Self { TextEntityType::Strikethrough(t.as_ref().clone()) }
237
238  pub fn text_url<T: AsRef<TextEntityTypeTextUrl>>(t: T) -> Self { TextEntityType::TextUrl(t.as_ref().clone()) }
239
240  pub fn underline<T: AsRef<TextEntityTypeUnderline>>(t: T) -> Self { TextEntityType::Underline(t.as_ref().clone()) }
241
242  pub fn url<T: AsRef<TextEntityTypeUrl>>(t: T) -> Self { TextEntityType::Url(t.as_ref().clone()) }
243
244}
245
246impl AsRef<TextEntityType> for TextEntityType {
247  fn as_ref(&self) -> &TextEntityType { self }
248}
249
250
251
252
253
254
255
256/// A bank card number. The getBankCardInfo method can be used to get information about the bank card
257#[derive(Debug, Clone, Default, Serialize, Deserialize)]
258pub struct TextEntityTypeBankCardNumber {
259  #[doc(hidden)]
260  #[serde(rename(serialize = "@type", deserialize = "@type"))]
261  td_name: String,
262  #[doc(hidden)]
263  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
264  extra: Option<String>,
265  
266}
267
268impl RObject for TextEntityTypeBankCardNumber {
269  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeBankCardNumber" }
270  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
271  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
272}
273
274
275impl TDTextEntityType for TextEntityTypeBankCardNumber {}
276
277
278
279impl TextEntityTypeBankCardNumber {
280  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
281  pub fn builder() -> RTDTextEntityTypeBankCardNumberBuilder {
282    let mut inner = TextEntityTypeBankCardNumber::default();
283    inner.td_name = "textEntityTypeBankCardNumber".to_string();
284    inner.extra = Some(Uuid::new_v4().to_string());
285    RTDTextEntityTypeBankCardNumberBuilder { inner }
286  }
287
288}
289
290#[doc(hidden)]
291pub struct RTDTextEntityTypeBankCardNumberBuilder {
292  inner: TextEntityTypeBankCardNumber
293}
294
295impl RTDTextEntityTypeBankCardNumberBuilder {
296  pub fn build(&self) -> TextEntityTypeBankCardNumber { self.inner.clone() }
297
298}
299
300impl AsRef<TextEntityTypeBankCardNumber> for TextEntityTypeBankCardNumber {
301  fn as_ref(&self) -> &TextEntityTypeBankCardNumber { self }
302}
303
304impl AsRef<TextEntityTypeBankCardNumber> for RTDTextEntityTypeBankCardNumberBuilder {
305  fn as_ref(&self) -> &TextEntityTypeBankCardNumber { &self.inner }
306}
307
308
309
310
311
312
313
314/// A bold text
315#[derive(Debug, Clone, Default, Serialize, Deserialize)]
316pub struct TextEntityTypeBold {
317  #[doc(hidden)]
318  #[serde(rename(serialize = "@type", deserialize = "@type"))]
319  td_name: String,
320  #[doc(hidden)]
321  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
322  extra: Option<String>,
323  
324}
325
326impl RObject for TextEntityTypeBold {
327  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeBold" }
328  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
329  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
330}
331
332
333impl TDTextEntityType for TextEntityTypeBold {}
334
335
336
337impl TextEntityTypeBold {
338  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
339  pub fn builder() -> RTDTextEntityTypeBoldBuilder {
340    let mut inner = TextEntityTypeBold::default();
341    inner.td_name = "textEntityTypeBold".to_string();
342    inner.extra = Some(Uuid::new_v4().to_string());
343    RTDTextEntityTypeBoldBuilder { inner }
344  }
345
346}
347
348#[doc(hidden)]
349pub struct RTDTextEntityTypeBoldBuilder {
350  inner: TextEntityTypeBold
351}
352
353impl RTDTextEntityTypeBoldBuilder {
354  pub fn build(&self) -> TextEntityTypeBold { self.inner.clone() }
355
356}
357
358impl AsRef<TextEntityTypeBold> for TextEntityTypeBold {
359  fn as_ref(&self) -> &TextEntityTypeBold { self }
360}
361
362impl AsRef<TextEntityTypeBold> for RTDTextEntityTypeBoldBuilder {
363  fn as_ref(&self) -> &TextEntityTypeBold { &self.inner }
364}
365
366
367
368
369
370
371
372/// A bot command, beginning with "/"
373#[derive(Debug, Clone, Default, Serialize, Deserialize)]
374pub struct TextEntityTypeBotCommand {
375  #[doc(hidden)]
376  #[serde(rename(serialize = "@type", deserialize = "@type"))]
377  td_name: String,
378  #[doc(hidden)]
379  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
380  extra: Option<String>,
381  
382}
383
384impl RObject for TextEntityTypeBotCommand {
385  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeBotCommand" }
386  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
387  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
388}
389
390
391impl TDTextEntityType for TextEntityTypeBotCommand {}
392
393
394
395impl TextEntityTypeBotCommand {
396  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
397  pub fn builder() -> RTDTextEntityTypeBotCommandBuilder {
398    let mut inner = TextEntityTypeBotCommand::default();
399    inner.td_name = "textEntityTypeBotCommand".to_string();
400    inner.extra = Some(Uuid::new_v4().to_string());
401    RTDTextEntityTypeBotCommandBuilder { inner }
402  }
403
404}
405
406#[doc(hidden)]
407pub struct RTDTextEntityTypeBotCommandBuilder {
408  inner: TextEntityTypeBotCommand
409}
410
411impl RTDTextEntityTypeBotCommandBuilder {
412  pub fn build(&self) -> TextEntityTypeBotCommand { self.inner.clone() }
413
414}
415
416impl AsRef<TextEntityTypeBotCommand> for TextEntityTypeBotCommand {
417  fn as_ref(&self) -> &TextEntityTypeBotCommand { self }
418}
419
420impl AsRef<TextEntityTypeBotCommand> for RTDTextEntityTypeBotCommandBuilder {
421  fn as_ref(&self) -> &TextEntityTypeBotCommand { &self.inner }
422}
423
424
425
426
427
428
429
430/// A cashtag text, beginning with "$" and consisting of capital English letters (e.g., "$USD")
431#[derive(Debug, Clone, Default, Serialize, Deserialize)]
432pub struct TextEntityTypeCashtag {
433  #[doc(hidden)]
434  #[serde(rename(serialize = "@type", deserialize = "@type"))]
435  td_name: String,
436  #[doc(hidden)]
437  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
438  extra: Option<String>,
439  
440}
441
442impl RObject for TextEntityTypeCashtag {
443  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeCashtag" }
444  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
445  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
446}
447
448
449impl TDTextEntityType for TextEntityTypeCashtag {}
450
451
452
453impl TextEntityTypeCashtag {
454  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
455  pub fn builder() -> RTDTextEntityTypeCashtagBuilder {
456    let mut inner = TextEntityTypeCashtag::default();
457    inner.td_name = "textEntityTypeCashtag".to_string();
458    inner.extra = Some(Uuid::new_v4().to_string());
459    RTDTextEntityTypeCashtagBuilder { inner }
460  }
461
462}
463
464#[doc(hidden)]
465pub struct RTDTextEntityTypeCashtagBuilder {
466  inner: TextEntityTypeCashtag
467}
468
469impl RTDTextEntityTypeCashtagBuilder {
470  pub fn build(&self) -> TextEntityTypeCashtag { self.inner.clone() }
471
472}
473
474impl AsRef<TextEntityTypeCashtag> for TextEntityTypeCashtag {
475  fn as_ref(&self) -> &TextEntityTypeCashtag { self }
476}
477
478impl AsRef<TextEntityTypeCashtag> for RTDTextEntityTypeCashtagBuilder {
479  fn as_ref(&self) -> &TextEntityTypeCashtag { &self.inner }
480}
481
482
483
484
485
486
487
488/// Text that must be formatted as if inside a code HTML tag
489#[derive(Debug, Clone, Default, Serialize, Deserialize)]
490pub struct TextEntityTypeCode {
491  #[doc(hidden)]
492  #[serde(rename(serialize = "@type", deserialize = "@type"))]
493  td_name: String,
494  #[doc(hidden)]
495  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
496  extra: Option<String>,
497  
498}
499
500impl RObject for TextEntityTypeCode {
501  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeCode" }
502  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
503  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
504}
505
506
507impl TDTextEntityType for TextEntityTypeCode {}
508
509
510
511impl TextEntityTypeCode {
512  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
513  pub fn builder() -> RTDTextEntityTypeCodeBuilder {
514    let mut inner = TextEntityTypeCode::default();
515    inner.td_name = "textEntityTypeCode".to_string();
516    inner.extra = Some(Uuid::new_v4().to_string());
517    RTDTextEntityTypeCodeBuilder { inner }
518  }
519
520}
521
522#[doc(hidden)]
523pub struct RTDTextEntityTypeCodeBuilder {
524  inner: TextEntityTypeCode
525}
526
527impl RTDTextEntityTypeCodeBuilder {
528  pub fn build(&self) -> TextEntityTypeCode { self.inner.clone() }
529
530}
531
532impl AsRef<TextEntityTypeCode> for TextEntityTypeCode {
533  fn as_ref(&self) -> &TextEntityTypeCode { self }
534}
535
536impl AsRef<TextEntityTypeCode> for RTDTextEntityTypeCodeBuilder {
537  fn as_ref(&self) -> &TextEntityTypeCode { &self.inner }
538}
539
540
541
542
543
544
545
546/// An email address
547#[derive(Debug, Clone, Default, Serialize, Deserialize)]
548pub struct TextEntityTypeEmailAddress {
549  #[doc(hidden)]
550  #[serde(rename(serialize = "@type", deserialize = "@type"))]
551  td_name: String,
552  #[doc(hidden)]
553  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
554  extra: Option<String>,
555  
556}
557
558impl RObject for TextEntityTypeEmailAddress {
559  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeEmailAddress" }
560  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
561  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
562}
563
564
565impl TDTextEntityType for TextEntityTypeEmailAddress {}
566
567
568
569impl TextEntityTypeEmailAddress {
570  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
571  pub fn builder() -> RTDTextEntityTypeEmailAddressBuilder {
572    let mut inner = TextEntityTypeEmailAddress::default();
573    inner.td_name = "textEntityTypeEmailAddress".to_string();
574    inner.extra = Some(Uuid::new_v4().to_string());
575    RTDTextEntityTypeEmailAddressBuilder { inner }
576  }
577
578}
579
580#[doc(hidden)]
581pub struct RTDTextEntityTypeEmailAddressBuilder {
582  inner: TextEntityTypeEmailAddress
583}
584
585impl RTDTextEntityTypeEmailAddressBuilder {
586  pub fn build(&self) -> TextEntityTypeEmailAddress { self.inner.clone() }
587
588}
589
590impl AsRef<TextEntityTypeEmailAddress> for TextEntityTypeEmailAddress {
591  fn as_ref(&self) -> &TextEntityTypeEmailAddress { self }
592}
593
594impl AsRef<TextEntityTypeEmailAddress> for RTDTextEntityTypeEmailAddressBuilder {
595  fn as_ref(&self) -> &TextEntityTypeEmailAddress { &self.inner }
596}
597
598
599
600
601
602
603
604/// A hashtag text, beginning with "#"
605#[derive(Debug, Clone, Default, Serialize, Deserialize)]
606pub struct TextEntityTypeHashtag {
607  #[doc(hidden)]
608  #[serde(rename(serialize = "@type", deserialize = "@type"))]
609  td_name: String,
610  #[doc(hidden)]
611  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
612  extra: Option<String>,
613  
614}
615
616impl RObject for TextEntityTypeHashtag {
617  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeHashtag" }
618  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
619  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
620}
621
622
623impl TDTextEntityType for TextEntityTypeHashtag {}
624
625
626
627impl TextEntityTypeHashtag {
628  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
629  pub fn builder() -> RTDTextEntityTypeHashtagBuilder {
630    let mut inner = TextEntityTypeHashtag::default();
631    inner.td_name = "textEntityTypeHashtag".to_string();
632    inner.extra = Some(Uuid::new_v4().to_string());
633    RTDTextEntityTypeHashtagBuilder { inner }
634  }
635
636}
637
638#[doc(hidden)]
639pub struct RTDTextEntityTypeHashtagBuilder {
640  inner: TextEntityTypeHashtag
641}
642
643impl RTDTextEntityTypeHashtagBuilder {
644  pub fn build(&self) -> TextEntityTypeHashtag { self.inner.clone() }
645
646}
647
648impl AsRef<TextEntityTypeHashtag> for TextEntityTypeHashtag {
649  fn as_ref(&self) -> &TextEntityTypeHashtag { self }
650}
651
652impl AsRef<TextEntityTypeHashtag> for RTDTextEntityTypeHashtagBuilder {
653  fn as_ref(&self) -> &TextEntityTypeHashtag { &self.inner }
654}
655
656
657
658
659
660
661
662/// An italic text
663#[derive(Debug, Clone, Default, Serialize, Deserialize)]
664pub struct TextEntityTypeItalic {
665  #[doc(hidden)]
666  #[serde(rename(serialize = "@type", deserialize = "@type"))]
667  td_name: String,
668  #[doc(hidden)]
669  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
670  extra: Option<String>,
671  
672}
673
674impl RObject for TextEntityTypeItalic {
675  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeItalic" }
676  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
677  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
678}
679
680
681impl TDTextEntityType for TextEntityTypeItalic {}
682
683
684
685impl TextEntityTypeItalic {
686  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
687  pub fn builder() -> RTDTextEntityTypeItalicBuilder {
688    let mut inner = TextEntityTypeItalic::default();
689    inner.td_name = "textEntityTypeItalic".to_string();
690    inner.extra = Some(Uuid::new_v4().to_string());
691    RTDTextEntityTypeItalicBuilder { inner }
692  }
693
694}
695
696#[doc(hidden)]
697pub struct RTDTextEntityTypeItalicBuilder {
698  inner: TextEntityTypeItalic
699}
700
701impl RTDTextEntityTypeItalicBuilder {
702  pub fn build(&self) -> TextEntityTypeItalic { self.inner.clone() }
703
704}
705
706impl AsRef<TextEntityTypeItalic> for TextEntityTypeItalic {
707  fn as_ref(&self) -> &TextEntityTypeItalic { self }
708}
709
710impl AsRef<TextEntityTypeItalic> for RTDTextEntityTypeItalicBuilder {
711  fn as_ref(&self) -> &TextEntityTypeItalic { &self.inner }
712}
713
714
715
716
717
718
719
720/// A media timestamp
721#[derive(Debug, Clone, Default, Serialize, Deserialize)]
722pub struct TextEntityTypeMediaTimestamp {
723  #[doc(hidden)]
724  #[serde(rename(serialize = "@type", deserialize = "@type"))]
725  td_name: String,
726  #[doc(hidden)]
727  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
728  extra: Option<String>,
729  /// Timestamp from which a video/audio/video note/voice note playing must start, in seconds. The media can be in the content or the web page preview of the current message, or in the same places in the replied message
730  media_timestamp: i64,
731  
732}
733
734impl RObject for TextEntityTypeMediaTimestamp {
735  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeMediaTimestamp" }
736  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
737  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
738}
739
740
741impl TDTextEntityType for TextEntityTypeMediaTimestamp {}
742
743
744
745impl TextEntityTypeMediaTimestamp {
746  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
747  pub fn builder() -> RTDTextEntityTypeMediaTimestampBuilder {
748    let mut inner = TextEntityTypeMediaTimestamp::default();
749    inner.td_name = "textEntityTypeMediaTimestamp".to_string();
750    inner.extra = Some(Uuid::new_v4().to_string());
751    RTDTextEntityTypeMediaTimestampBuilder { inner }
752  }
753
754  pub fn media_timestamp(&self) -> i64 { self.media_timestamp }
755
756}
757
758#[doc(hidden)]
759pub struct RTDTextEntityTypeMediaTimestampBuilder {
760  inner: TextEntityTypeMediaTimestamp
761}
762
763impl RTDTextEntityTypeMediaTimestampBuilder {
764  pub fn build(&self) -> TextEntityTypeMediaTimestamp { self.inner.clone() }
765
766   
767  pub fn media_timestamp(&mut self, media_timestamp: i64) -> &mut Self {
768    self.inner.media_timestamp = media_timestamp;
769    self
770  }
771
772}
773
774impl AsRef<TextEntityTypeMediaTimestamp> for TextEntityTypeMediaTimestamp {
775  fn as_ref(&self) -> &TextEntityTypeMediaTimestamp { self }
776}
777
778impl AsRef<TextEntityTypeMediaTimestamp> for RTDTextEntityTypeMediaTimestampBuilder {
779  fn as_ref(&self) -> &TextEntityTypeMediaTimestamp { &self.inner }
780}
781
782
783
784
785
786
787
788/// A mention of a user by their username
789#[derive(Debug, Clone, Default, Serialize, Deserialize)]
790pub struct TextEntityTypeMention {
791  #[doc(hidden)]
792  #[serde(rename(serialize = "@type", deserialize = "@type"))]
793  td_name: String,
794  #[doc(hidden)]
795  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
796  extra: Option<String>,
797  
798}
799
800impl RObject for TextEntityTypeMention {
801  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeMention" }
802  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
803  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
804}
805
806
807impl TDTextEntityType for TextEntityTypeMention {}
808
809
810
811impl TextEntityTypeMention {
812  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
813  pub fn builder() -> RTDTextEntityTypeMentionBuilder {
814    let mut inner = TextEntityTypeMention::default();
815    inner.td_name = "textEntityTypeMention".to_string();
816    inner.extra = Some(Uuid::new_v4().to_string());
817    RTDTextEntityTypeMentionBuilder { inner }
818  }
819
820}
821
822#[doc(hidden)]
823pub struct RTDTextEntityTypeMentionBuilder {
824  inner: TextEntityTypeMention
825}
826
827impl RTDTextEntityTypeMentionBuilder {
828  pub fn build(&self) -> TextEntityTypeMention { self.inner.clone() }
829
830}
831
832impl AsRef<TextEntityTypeMention> for TextEntityTypeMention {
833  fn as_ref(&self) -> &TextEntityTypeMention { self }
834}
835
836impl AsRef<TextEntityTypeMention> for RTDTextEntityTypeMentionBuilder {
837  fn as_ref(&self) -> &TextEntityTypeMention { &self.inner }
838}
839
840
841
842
843
844
845
846/// A text shows instead of a raw mention of the user (e.g., when the user has no username)
847#[derive(Debug, Clone, Default, Serialize, Deserialize)]
848pub struct TextEntityTypeMentionName {
849  #[doc(hidden)]
850  #[serde(rename(serialize = "@type", deserialize = "@type"))]
851  td_name: String,
852  #[doc(hidden)]
853  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
854  extra: Option<String>,
855  /// Identifier of the mentioned user
856  user_id: i64,
857  
858}
859
860impl RObject for TextEntityTypeMentionName {
861  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeMentionName" }
862  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
863  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
864}
865
866
867impl TDTextEntityType for TextEntityTypeMentionName {}
868
869
870
871impl TextEntityTypeMentionName {
872  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
873  pub fn builder() -> RTDTextEntityTypeMentionNameBuilder {
874    let mut inner = TextEntityTypeMentionName::default();
875    inner.td_name = "textEntityTypeMentionName".to_string();
876    inner.extra = Some(Uuid::new_v4().to_string());
877    RTDTextEntityTypeMentionNameBuilder { inner }
878  }
879
880  pub fn user_id(&self) -> i64 { self.user_id }
881
882}
883
884#[doc(hidden)]
885pub struct RTDTextEntityTypeMentionNameBuilder {
886  inner: TextEntityTypeMentionName
887}
888
889impl RTDTextEntityTypeMentionNameBuilder {
890  pub fn build(&self) -> TextEntityTypeMentionName { self.inner.clone() }
891
892   
893  pub fn user_id(&mut self, user_id: i64) -> &mut Self {
894    self.inner.user_id = user_id;
895    self
896  }
897
898}
899
900impl AsRef<TextEntityTypeMentionName> for TextEntityTypeMentionName {
901  fn as_ref(&self) -> &TextEntityTypeMentionName { self }
902}
903
904impl AsRef<TextEntityTypeMentionName> for RTDTextEntityTypeMentionNameBuilder {
905  fn as_ref(&self) -> &TextEntityTypeMentionName { &self.inner }
906}
907
908
909
910
911
912
913
914/// A phone number
915#[derive(Debug, Clone, Default, Serialize, Deserialize)]
916pub struct TextEntityTypePhoneNumber {
917  #[doc(hidden)]
918  #[serde(rename(serialize = "@type", deserialize = "@type"))]
919  td_name: String,
920  #[doc(hidden)]
921  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
922  extra: Option<String>,
923  
924}
925
926impl RObject for TextEntityTypePhoneNumber {
927  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypePhoneNumber" }
928  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
929  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
930}
931
932
933impl TDTextEntityType for TextEntityTypePhoneNumber {}
934
935
936
937impl TextEntityTypePhoneNumber {
938  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
939  pub fn builder() -> RTDTextEntityTypePhoneNumberBuilder {
940    let mut inner = TextEntityTypePhoneNumber::default();
941    inner.td_name = "textEntityTypePhoneNumber".to_string();
942    inner.extra = Some(Uuid::new_v4().to_string());
943    RTDTextEntityTypePhoneNumberBuilder { inner }
944  }
945
946}
947
948#[doc(hidden)]
949pub struct RTDTextEntityTypePhoneNumberBuilder {
950  inner: TextEntityTypePhoneNumber
951}
952
953impl RTDTextEntityTypePhoneNumberBuilder {
954  pub fn build(&self) -> TextEntityTypePhoneNumber { self.inner.clone() }
955
956}
957
958impl AsRef<TextEntityTypePhoneNumber> for TextEntityTypePhoneNumber {
959  fn as_ref(&self) -> &TextEntityTypePhoneNumber { self }
960}
961
962impl AsRef<TextEntityTypePhoneNumber> for RTDTextEntityTypePhoneNumberBuilder {
963  fn as_ref(&self) -> &TextEntityTypePhoneNumber { &self.inner }
964}
965
966
967
968
969
970
971
972/// Text that must be formatted as if inside a pre HTML tag
973#[derive(Debug, Clone, Default, Serialize, Deserialize)]
974pub struct TextEntityTypePre {
975  #[doc(hidden)]
976  #[serde(rename(serialize = "@type", deserialize = "@type"))]
977  td_name: String,
978  #[doc(hidden)]
979  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
980  extra: Option<String>,
981  
982}
983
984impl RObject for TextEntityTypePre {
985  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypePre" }
986  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
987  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
988}
989
990
991impl TDTextEntityType for TextEntityTypePre {}
992
993
994
995impl TextEntityTypePre {
996  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
997  pub fn builder() -> RTDTextEntityTypePreBuilder {
998    let mut inner = TextEntityTypePre::default();
999    inner.td_name = "textEntityTypePre".to_string();
1000    inner.extra = Some(Uuid::new_v4().to_string());
1001    RTDTextEntityTypePreBuilder { inner }
1002  }
1003
1004}
1005
1006#[doc(hidden)]
1007pub struct RTDTextEntityTypePreBuilder {
1008  inner: TextEntityTypePre
1009}
1010
1011impl RTDTextEntityTypePreBuilder {
1012  pub fn build(&self) -> TextEntityTypePre { self.inner.clone() }
1013
1014}
1015
1016impl AsRef<TextEntityTypePre> for TextEntityTypePre {
1017  fn as_ref(&self) -> &TextEntityTypePre { self }
1018}
1019
1020impl AsRef<TextEntityTypePre> for RTDTextEntityTypePreBuilder {
1021  fn as_ref(&self) -> &TextEntityTypePre { &self.inner }
1022}
1023
1024
1025
1026
1027
1028
1029
1030/// Text that must be formatted as if inside pre, and code HTML tags
1031#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1032pub struct TextEntityTypePreCode {
1033  #[doc(hidden)]
1034  #[serde(rename(serialize = "@type", deserialize = "@type"))]
1035  td_name: String,
1036  #[doc(hidden)]
1037  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1038  extra: Option<String>,
1039  /// Programming language of the code; as defined by the sender
1040  language: String,
1041  
1042}
1043
1044impl RObject for TextEntityTypePreCode {
1045  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypePreCode" }
1046  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1047  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1048}
1049
1050
1051impl TDTextEntityType for TextEntityTypePreCode {}
1052
1053
1054
1055impl TextEntityTypePreCode {
1056  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1057  pub fn builder() -> RTDTextEntityTypePreCodeBuilder {
1058    let mut inner = TextEntityTypePreCode::default();
1059    inner.td_name = "textEntityTypePreCode".to_string();
1060    inner.extra = Some(Uuid::new_v4().to_string());
1061    RTDTextEntityTypePreCodeBuilder { inner }
1062  }
1063
1064  pub fn language(&self) -> &String { &self.language }
1065
1066}
1067
1068#[doc(hidden)]
1069pub struct RTDTextEntityTypePreCodeBuilder {
1070  inner: TextEntityTypePreCode
1071}
1072
1073impl RTDTextEntityTypePreCodeBuilder {
1074  pub fn build(&self) -> TextEntityTypePreCode { self.inner.clone() }
1075
1076   
1077  pub fn language<T: AsRef<str>>(&mut self, language: T) -> &mut Self {
1078    self.inner.language = language.as_ref().to_string();
1079    self
1080  }
1081
1082}
1083
1084impl AsRef<TextEntityTypePreCode> for TextEntityTypePreCode {
1085  fn as_ref(&self) -> &TextEntityTypePreCode { self }
1086}
1087
1088impl AsRef<TextEntityTypePreCode> for RTDTextEntityTypePreCodeBuilder {
1089  fn as_ref(&self) -> &TextEntityTypePreCode { &self.inner }
1090}
1091
1092
1093
1094
1095
1096
1097
1098/// A strikethrough text
1099#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1100pub struct TextEntityTypeStrikethrough {
1101  #[doc(hidden)]
1102  #[serde(rename(serialize = "@type", deserialize = "@type"))]
1103  td_name: String,
1104  #[doc(hidden)]
1105  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1106  extra: Option<String>,
1107  
1108}
1109
1110impl RObject for TextEntityTypeStrikethrough {
1111  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeStrikethrough" }
1112  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1113  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1114}
1115
1116
1117impl TDTextEntityType for TextEntityTypeStrikethrough {}
1118
1119
1120
1121impl TextEntityTypeStrikethrough {
1122  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1123  pub fn builder() -> RTDTextEntityTypeStrikethroughBuilder {
1124    let mut inner = TextEntityTypeStrikethrough::default();
1125    inner.td_name = "textEntityTypeStrikethrough".to_string();
1126    inner.extra = Some(Uuid::new_v4().to_string());
1127    RTDTextEntityTypeStrikethroughBuilder { inner }
1128  }
1129
1130}
1131
1132#[doc(hidden)]
1133pub struct RTDTextEntityTypeStrikethroughBuilder {
1134  inner: TextEntityTypeStrikethrough
1135}
1136
1137impl RTDTextEntityTypeStrikethroughBuilder {
1138  pub fn build(&self) -> TextEntityTypeStrikethrough { self.inner.clone() }
1139
1140}
1141
1142impl AsRef<TextEntityTypeStrikethrough> for TextEntityTypeStrikethrough {
1143  fn as_ref(&self) -> &TextEntityTypeStrikethrough { self }
1144}
1145
1146impl AsRef<TextEntityTypeStrikethrough> for RTDTextEntityTypeStrikethroughBuilder {
1147  fn as_ref(&self) -> &TextEntityTypeStrikethrough { &self.inner }
1148}
1149
1150
1151
1152
1153
1154
1155
1156/// A text description shown instead of a raw URL
1157#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1158pub struct TextEntityTypeTextUrl {
1159  #[doc(hidden)]
1160  #[serde(rename(serialize = "@type", deserialize = "@type"))]
1161  td_name: String,
1162  #[doc(hidden)]
1163  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1164  extra: Option<String>,
1165  /// HTTP or tg:// URL to be opened when the link is clicked
1166  url: String,
1167  
1168}
1169
1170impl RObject for TextEntityTypeTextUrl {
1171  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeTextUrl" }
1172  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1173  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1174}
1175
1176
1177impl TDTextEntityType for TextEntityTypeTextUrl {}
1178
1179
1180
1181impl TextEntityTypeTextUrl {
1182  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1183  pub fn builder() -> RTDTextEntityTypeTextUrlBuilder {
1184    let mut inner = TextEntityTypeTextUrl::default();
1185    inner.td_name = "textEntityTypeTextUrl".to_string();
1186    inner.extra = Some(Uuid::new_v4().to_string());
1187    RTDTextEntityTypeTextUrlBuilder { inner }
1188  }
1189
1190  pub fn url(&self) -> &String { &self.url }
1191
1192}
1193
1194#[doc(hidden)]
1195pub struct RTDTextEntityTypeTextUrlBuilder {
1196  inner: TextEntityTypeTextUrl
1197}
1198
1199impl RTDTextEntityTypeTextUrlBuilder {
1200  pub fn build(&self) -> TextEntityTypeTextUrl { self.inner.clone() }
1201
1202   
1203  pub fn url<T: AsRef<str>>(&mut self, url: T) -> &mut Self {
1204    self.inner.url = url.as_ref().to_string();
1205    self
1206  }
1207
1208}
1209
1210impl AsRef<TextEntityTypeTextUrl> for TextEntityTypeTextUrl {
1211  fn as_ref(&self) -> &TextEntityTypeTextUrl { self }
1212}
1213
1214impl AsRef<TextEntityTypeTextUrl> for RTDTextEntityTypeTextUrlBuilder {
1215  fn as_ref(&self) -> &TextEntityTypeTextUrl { &self.inner }
1216}
1217
1218
1219
1220
1221
1222
1223
1224/// An underlined text
1225#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1226pub struct TextEntityTypeUnderline {
1227  #[doc(hidden)]
1228  #[serde(rename(serialize = "@type", deserialize = "@type"))]
1229  td_name: String,
1230  #[doc(hidden)]
1231  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1232  extra: Option<String>,
1233  
1234}
1235
1236impl RObject for TextEntityTypeUnderline {
1237  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeUnderline" }
1238  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1239  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1240}
1241
1242
1243impl TDTextEntityType for TextEntityTypeUnderline {}
1244
1245
1246
1247impl TextEntityTypeUnderline {
1248  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1249  pub fn builder() -> RTDTextEntityTypeUnderlineBuilder {
1250    let mut inner = TextEntityTypeUnderline::default();
1251    inner.td_name = "textEntityTypeUnderline".to_string();
1252    inner.extra = Some(Uuid::new_v4().to_string());
1253    RTDTextEntityTypeUnderlineBuilder { inner }
1254  }
1255
1256}
1257
1258#[doc(hidden)]
1259pub struct RTDTextEntityTypeUnderlineBuilder {
1260  inner: TextEntityTypeUnderline
1261}
1262
1263impl RTDTextEntityTypeUnderlineBuilder {
1264  pub fn build(&self) -> TextEntityTypeUnderline { self.inner.clone() }
1265
1266}
1267
1268impl AsRef<TextEntityTypeUnderline> for TextEntityTypeUnderline {
1269  fn as_ref(&self) -> &TextEntityTypeUnderline { self }
1270}
1271
1272impl AsRef<TextEntityTypeUnderline> for RTDTextEntityTypeUnderlineBuilder {
1273  fn as_ref(&self) -> &TextEntityTypeUnderline { &self.inner }
1274}
1275
1276
1277
1278
1279
1280
1281
1282/// An HTTP URL
1283#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1284pub struct TextEntityTypeUrl {
1285  #[doc(hidden)]
1286  #[serde(rename(serialize = "@type", deserialize = "@type"))]
1287  td_name: String,
1288  #[doc(hidden)]
1289  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1290  extra: Option<String>,
1291  
1292}
1293
1294impl RObject for TextEntityTypeUrl {
1295  #[doc(hidden)] fn td_name(&self) -> &'static str { "textEntityTypeUrl" }
1296  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1297  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1298}
1299
1300
1301impl TDTextEntityType for TextEntityTypeUrl {}
1302
1303
1304
1305impl TextEntityTypeUrl {
1306  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1307  pub fn builder() -> RTDTextEntityTypeUrlBuilder {
1308    let mut inner = TextEntityTypeUrl::default();
1309    inner.td_name = "textEntityTypeUrl".to_string();
1310    inner.extra = Some(Uuid::new_v4().to_string());
1311    RTDTextEntityTypeUrlBuilder { inner }
1312  }
1313
1314}
1315
1316#[doc(hidden)]
1317pub struct RTDTextEntityTypeUrlBuilder {
1318  inner: TextEntityTypeUrl
1319}
1320
1321impl RTDTextEntityTypeUrlBuilder {
1322  pub fn build(&self) -> TextEntityTypeUrl { self.inner.clone() }
1323
1324}
1325
1326impl AsRef<TextEntityTypeUrl> for TextEntityTypeUrl {
1327  fn as_ref(&self) -> &TextEntityTypeUrl { self }
1328}
1329
1330impl AsRef<TextEntityTypeUrl> for RTDTextEntityTypeUrlBuilder {
1331  fn as_ref(&self) -> &TextEntityTypeUrl { &self.inner }
1332}
1333
1334
1335
rtdlib/types/text_entity_type.rs

rtdlib/types/
text_entity_type.rs
