rust_tdlib/types/
text_entity_type.rs

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

rust_tdlib/types/
text_entity_type.rs
