rust_tdlib/types/
device_token.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Represents a data needed to subscribe for push notifications through registerDevice method. To use specific push notification service, the correct application platform must be specified and a valid server authentication data must be uploaded at https://my.telegram.org
8pub trait TDDeviceToken: Debug + RObject {}
9
10/// Represents a data needed to subscribe for push notifications through registerDevice method. To use specific push notification service, the correct application platform must be specified and a valid server authentication data must be uploaded at https://my.telegram.org
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum DeviceToken {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// A token for Apple Push Notification service
18    #[serde(rename = "deviceTokenApplePush")]
19    ApplePush(DeviceTokenApplePush),
20    /// A token for Apple Push Notification service VoIP notifications
21    #[serde(rename = "deviceTokenApplePushVoIP")]
22    ApplePushVoIP(DeviceTokenApplePushVoIP),
23    /// A token for BlackBerry Push Service
24    #[serde(rename = "deviceTokenBlackBerryPush")]
25    BlackBerryPush(DeviceTokenBlackBerryPush),
26    /// A token for Firebase Cloud Messaging
27    #[serde(rename = "deviceTokenFirebaseCloudMessaging")]
28    FirebaseCloudMessaging(DeviceTokenFirebaseCloudMessaging),
29    /// A token for Microsoft Push Notification Service
30    #[serde(rename = "deviceTokenMicrosoftPush")]
31    MicrosoftPush(DeviceTokenMicrosoftPush),
32    /// A token for Microsoft Push Notification Service VoIP channel
33    #[serde(rename = "deviceTokenMicrosoftPushVoIP")]
34    MicrosoftPushVoIP(DeviceTokenMicrosoftPushVoIP),
35    /// A token for Simple Push API for Firefox OS
36    #[serde(rename = "deviceTokenSimplePush")]
37    SimplePush(DeviceTokenSimplePush),
38    /// A token for Tizen Push Service
39    #[serde(rename = "deviceTokenTizenPush")]
40    TizenPush(DeviceTokenTizenPush),
41    /// A token for Ubuntu Push Client service
42    #[serde(rename = "deviceTokenUbuntuPush")]
43    UbuntuPush(DeviceTokenUbuntuPush),
44    /// A token for web Push API
45    #[serde(rename = "deviceTokenWebPush")]
46    WebPush(DeviceTokenWebPush),
47    /// A token for Windows Push Notification Services
48    #[serde(rename = "deviceTokenWindowsPush")]
49    WindowsPush(DeviceTokenWindowsPush),
50}
51
52impl RObject for DeviceToken {
53    #[doc(hidden)]
54    fn extra(&self) -> Option<&str> {
55        match self {
56            DeviceToken::ApplePush(t) => t.extra(),
57            DeviceToken::ApplePushVoIP(t) => t.extra(),
58            DeviceToken::BlackBerryPush(t) => t.extra(),
59            DeviceToken::FirebaseCloudMessaging(t) => t.extra(),
60            DeviceToken::MicrosoftPush(t) => t.extra(),
61            DeviceToken::MicrosoftPushVoIP(t) => t.extra(),
62            DeviceToken::SimplePush(t) => t.extra(),
63            DeviceToken::TizenPush(t) => t.extra(),
64            DeviceToken::UbuntuPush(t) => t.extra(),
65            DeviceToken::WebPush(t) => t.extra(),
66            DeviceToken::WindowsPush(t) => t.extra(),
67
68            _ => None,
69        }
70    }
71    #[doc(hidden)]
72    fn client_id(&self) -> Option<i32> {
73        match self {
74            DeviceToken::ApplePush(t) => t.client_id(),
75            DeviceToken::ApplePushVoIP(t) => t.client_id(),
76            DeviceToken::BlackBerryPush(t) => t.client_id(),
77            DeviceToken::FirebaseCloudMessaging(t) => t.client_id(),
78            DeviceToken::MicrosoftPush(t) => t.client_id(),
79            DeviceToken::MicrosoftPushVoIP(t) => t.client_id(),
80            DeviceToken::SimplePush(t) => t.client_id(),
81            DeviceToken::TizenPush(t) => t.client_id(),
82            DeviceToken::UbuntuPush(t) => t.client_id(),
83            DeviceToken::WebPush(t) => t.client_id(),
84            DeviceToken::WindowsPush(t) => t.client_id(),
85
86            _ => None,
87        }
88    }
89}
90
91impl DeviceToken {
92    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
93        Ok(serde_json::from_str(json.as_ref())?)
94    }
95    #[doc(hidden)]
96    pub fn _is_default(&self) -> bool {
97        matches!(self, DeviceToken::_Default)
98    }
99}
100
101impl AsRef<DeviceToken> for DeviceToken {
102    fn as_ref(&self) -> &DeviceToken {
103        self
104    }
105}
106
107/// A token for Apple Push Notification service
108#[derive(Debug, Clone, Default, Serialize, Deserialize)]
109pub struct DeviceTokenApplePush {
110    #[doc(hidden)]
111    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
112    extra: Option<String>,
113    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
114    client_id: Option<i32>,
115    /// Device token; may be empty to deregister a device
116
117    #[serde(default)]
118    device_token: String,
119    /// True, if App Sandbox is enabled
120
121    #[serde(default)]
122    is_app_sandbox: bool,
123}
124
125impl RObject for DeviceTokenApplePush {
126    #[doc(hidden)]
127    fn extra(&self) -> Option<&str> {
128        self.extra.as_deref()
129    }
130    #[doc(hidden)]
131    fn client_id(&self) -> Option<i32> {
132        self.client_id
133    }
134}
135
136impl TDDeviceToken for DeviceTokenApplePush {}
137
138impl DeviceTokenApplePush {
139    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
140        Ok(serde_json::from_str(json.as_ref())?)
141    }
142    pub fn builder() -> DeviceTokenApplePushBuilder {
143        let mut inner = DeviceTokenApplePush::default();
144        inner.extra = Some(Uuid::new_v4().to_string());
145
146        DeviceTokenApplePushBuilder { inner }
147    }
148
149    pub fn device_token(&self) -> &String {
150        &self.device_token
151    }
152
153    pub fn is_app_sandbox(&self) -> bool {
154        self.is_app_sandbox
155    }
156}
157
158#[doc(hidden)]
159pub struct DeviceTokenApplePushBuilder {
160    inner: DeviceTokenApplePush,
161}
162
163#[deprecated]
164pub type RTDDeviceTokenApplePushBuilder = DeviceTokenApplePushBuilder;
165
166impl DeviceTokenApplePushBuilder {
167    pub fn build(&self) -> DeviceTokenApplePush {
168        self.inner.clone()
169    }
170
171    pub fn device_token<T: AsRef<str>>(&mut self, device_token: T) -> &mut Self {
172        self.inner.device_token = device_token.as_ref().to_string();
173        self
174    }
175
176    pub fn is_app_sandbox(&mut self, is_app_sandbox: bool) -> &mut Self {
177        self.inner.is_app_sandbox = is_app_sandbox;
178        self
179    }
180}
181
182impl AsRef<DeviceTokenApplePush> for DeviceTokenApplePush {
183    fn as_ref(&self) -> &DeviceTokenApplePush {
184        self
185    }
186}
187
188impl AsRef<DeviceTokenApplePush> for DeviceTokenApplePushBuilder {
189    fn as_ref(&self) -> &DeviceTokenApplePush {
190        &self.inner
191    }
192}
193
194/// A token for Apple Push Notification service VoIP notifications
195#[derive(Debug, Clone, Default, Serialize, Deserialize)]
196pub struct DeviceTokenApplePushVoIP {
197    #[doc(hidden)]
198    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
199    extra: Option<String>,
200    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
201    client_id: Option<i32>,
202    /// Device token; may be empty to deregister a device
203
204    #[serde(default)]
205    device_token: String,
206    /// True, if App Sandbox is enabled
207
208    #[serde(default)]
209    is_app_sandbox: bool,
210    /// True, if push notifications must be additionally encrypted
211
212    #[serde(default)]
213    encrypt: bool,
214}
215
216impl RObject for DeviceTokenApplePushVoIP {
217    #[doc(hidden)]
218    fn extra(&self) -> Option<&str> {
219        self.extra.as_deref()
220    }
221    #[doc(hidden)]
222    fn client_id(&self) -> Option<i32> {
223        self.client_id
224    }
225}
226
227impl TDDeviceToken for DeviceTokenApplePushVoIP {}
228
229impl DeviceTokenApplePushVoIP {
230    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
231        Ok(serde_json::from_str(json.as_ref())?)
232    }
233    pub fn builder() -> DeviceTokenApplePushVoIPBuilder {
234        let mut inner = DeviceTokenApplePushVoIP::default();
235        inner.extra = Some(Uuid::new_v4().to_string());
236
237        DeviceTokenApplePushVoIPBuilder { inner }
238    }
239
240    pub fn device_token(&self) -> &String {
241        &self.device_token
242    }
243
244    pub fn is_app_sandbox(&self) -> bool {
245        self.is_app_sandbox
246    }
247
248    pub fn encrypt(&self) -> bool {
249        self.encrypt
250    }
251}
252
253#[doc(hidden)]
254pub struct DeviceTokenApplePushVoIPBuilder {
255    inner: DeviceTokenApplePushVoIP,
256}
257
258#[deprecated]
259pub type RTDDeviceTokenApplePushVoIPBuilder = DeviceTokenApplePushVoIPBuilder;
260
261impl DeviceTokenApplePushVoIPBuilder {
262    pub fn build(&self) -> DeviceTokenApplePushVoIP {
263        self.inner.clone()
264    }
265
266    pub fn device_token<T: AsRef<str>>(&mut self, device_token: T) -> &mut Self {
267        self.inner.device_token = device_token.as_ref().to_string();
268        self
269    }
270
271    pub fn is_app_sandbox(&mut self, is_app_sandbox: bool) -> &mut Self {
272        self.inner.is_app_sandbox = is_app_sandbox;
273        self
274    }
275
276    pub fn encrypt(&mut self, encrypt: bool) -> &mut Self {
277        self.inner.encrypt = encrypt;
278        self
279    }
280}
281
282impl AsRef<DeviceTokenApplePushVoIP> for DeviceTokenApplePushVoIP {
283    fn as_ref(&self) -> &DeviceTokenApplePushVoIP {
284        self
285    }
286}
287
288impl AsRef<DeviceTokenApplePushVoIP> for DeviceTokenApplePushVoIPBuilder {
289    fn as_ref(&self) -> &DeviceTokenApplePushVoIP {
290        &self.inner
291    }
292}
293
294/// A token for BlackBerry Push Service
295#[derive(Debug, Clone, Default, Serialize, Deserialize)]
296pub struct DeviceTokenBlackBerryPush {
297    #[doc(hidden)]
298    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
299    extra: Option<String>,
300    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
301    client_id: Option<i32>,
302    /// Token; may be empty to deregister a device
303
304    #[serde(default)]
305    token: String,
306}
307
308impl RObject for DeviceTokenBlackBerryPush {
309    #[doc(hidden)]
310    fn extra(&self) -> Option<&str> {
311        self.extra.as_deref()
312    }
313    #[doc(hidden)]
314    fn client_id(&self) -> Option<i32> {
315        self.client_id
316    }
317}
318
319impl TDDeviceToken for DeviceTokenBlackBerryPush {}
320
321impl DeviceTokenBlackBerryPush {
322    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
323        Ok(serde_json::from_str(json.as_ref())?)
324    }
325    pub fn builder() -> DeviceTokenBlackBerryPushBuilder {
326        let mut inner = DeviceTokenBlackBerryPush::default();
327        inner.extra = Some(Uuid::new_v4().to_string());
328
329        DeviceTokenBlackBerryPushBuilder { inner }
330    }
331
332    pub fn token(&self) -> &String {
333        &self.token
334    }
335}
336
337#[doc(hidden)]
338pub struct DeviceTokenBlackBerryPushBuilder {
339    inner: DeviceTokenBlackBerryPush,
340}
341
342#[deprecated]
343pub type RTDDeviceTokenBlackBerryPushBuilder = DeviceTokenBlackBerryPushBuilder;
344
345impl DeviceTokenBlackBerryPushBuilder {
346    pub fn build(&self) -> DeviceTokenBlackBerryPush {
347        self.inner.clone()
348    }
349
350    pub fn token<T: AsRef<str>>(&mut self, token: T) -> &mut Self {
351        self.inner.token = token.as_ref().to_string();
352        self
353    }
354}
355
356impl AsRef<DeviceTokenBlackBerryPush> for DeviceTokenBlackBerryPush {
357    fn as_ref(&self) -> &DeviceTokenBlackBerryPush {
358        self
359    }
360}
361
362impl AsRef<DeviceTokenBlackBerryPush> for DeviceTokenBlackBerryPushBuilder {
363    fn as_ref(&self) -> &DeviceTokenBlackBerryPush {
364        &self.inner
365    }
366}
367
368/// A token for Firebase Cloud Messaging
369#[derive(Debug, Clone, Default, Serialize, Deserialize)]
370pub struct DeviceTokenFirebaseCloudMessaging {
371    #[doc(hidden)]
372    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
373    extra: Option<String>,
374    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
375    client_id: Option<i32>,
376    /// Device registration token; may be empty to deregister a device
377
378    #[serde(default)]
379    token: String,
380    /// True, if push notifications must be additionally encrypted
381
382    #[serde(default)]
383    encrypt: bool,
384}
385
386impl RObject for DeviceTokenFirebaseCloudMessaging {
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 TDDeviceToken for DeviceTokenFirebaseCloudMessaging {}
398
399impl DeviceTokenFirebaseCloudMessaging {
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() -> DeviceTokenFirebaseCloudMessagingBuilder {
404        let mut inner = DeviceTokenFirebaseCloudMessaging::default();
405        inner.extra = Some(Uuid::new_v4().to_string());
406
407        DeviceTokenFirebaseCloudMessagingBuilder { inner }
408    }
409
410    pub fn token(&self) -> &String {
411        &self.token
412    }
413
414    pub fn encrypt(&self) -> bool {
415        self.encrypt
416    }
417}
418
419#[doc(hidden)]
420pub struct DeviceTokenFirebaseCloudMessagingBuilder {
421    inner: DeviceTokenFirebaseCloudMessaging,
422}
423
424#[deprecated]
425pub type RTDDeviceTokenFirebaseCloudMessagingBuilder = DeviceTokenFirebaseCloudMessagingBuilder;
426
427impl DeviceTokenFirebaseCloudMessagingBuilder {
428    pub fn build(&self) -> DeviceTokenFirebaseCloudMessaging {
429        self.inner.clone()
430    }
431
432    pub fn token<T: AsRef<str>>(&mut self, token: T) -> &mut Self {
433        self.inner.token = token.as_ref().to_string();
434        self
435    }
436
437    pub fn encrypt(&mut self, encrypt: bool) -> &mut Self {
438        self.inner.encrypt = encrypt;
439        self
440    }
441}
442
443impl AsRef<DeviceTokenFirebaseCloudMessaging> for DeviceTokenFirebaseCloudMessaging {
444    fn as_ref(&self) -> &DeviceTokenFirebaseCloudMessaging {
445        self
446    }
447}
448
449impl AsRef<DeviceTokenFirebaseCloudMessaging> for DeviceTokenFirebaseCloudMessagingBuilder {
450    fn as_ref(&self) -> &DeviceTokenFirebaseCloudMessaging {
451        &self.inner
452    }
453}
454
455/// A token for Microsoft Push Notification Service
456#[derive(Debug, Clone, Default, Serialize, Deserialize)]
457pub struct DeviceTokenMicrosoftPush {
458    #[doc(hidden)]
459    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
460    extra: Option<String>,
461    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
462    client_id: Option<i32>,
463    /// Push notification channel URI; may be empty to deregister a device
464
465    #[serde(default)]
466    channel_uri: String,
467}
468
469impl RObject for DeviceTokenMicrosoftPush {
470    #[doc(hidden)]
471    fn extra(&self) -> Option<&str> {
472        self.extra.as_deref()
473    }
474    #[doc(hidden)]
475    fn client_id(&self) -> Option<i32> {
476        self.client_id
477    }
478}
479
480impl TDDeviceToken for DeviceTokenMicrosoftPush {}
481
482impl DeviceTokenMicrosoftPush {
483    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
484        Ok(serde_json::from_str(json.as_ref())?)
485    }
486    pub fn builder() -> DeviceTokenMicrosoftPushBuilder {
487        let mut inner = DeviceTokenMicrosoftPush::default();
488        inner.extra = Some(Uuid::new_v4().to_string());
489
490        DeviceTokenMicrosoftPushBuilder { inner }
491    }
492
493    pub fn channel_uri(&self) -> &String {
494        &self.channel_uri
495    }
496}
497
498#[doc(hidden)]
499pub struct DeviceTokenMicrosoftPushBuilder {
500    inner: DeviceTokenMicrosoftPush,
501}
502
503#[deprecated]
504pub type RTDDeviceTokenMicrosoftPushBuilder = DeviceTokenMicrosoftPushBuilder;
505
506impl DeviceTokenMicrosoftPushBuilder {
507    pub fn build(&self) -> DeviceTokenMicrosoftPush {
508        self.inner.clone()
509    }
510
511    pub fn channel_uri<T: AsRef<str>>(&mut self, channel_uri: T) -> &mut Self {
512        self.inner.channel_uri = channel_uri.as_ref().to_string();
513        self
514    }
515}
516
517impl AsRef<DeviceTokenMicrosoftPush> for DeviceTokenMicrosoftPush {
518    fn as_ref(&self) -> &DeviceTokenMicrosoftPush {
519        self
520    }
521}
522
523impl AsRef<DeviceTokenMicrosoftPush> for DeviceTokenMicrosoftPushBuilder {
524    fn as_ref(&self) -> &DeviceTokenMicrosoftPush {
525        &self.inner
526    }
527}
528
529/// A token for Microsoft Push Notification Service VoIP channel
530#[derive(Debug, Clone, Default, Serialize, Deserialize)]
531pub struct DeviceTokenMicrosoftPushVoIP {
532    #[doc(hidden)]
533    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
534    extra: Option<String>,
535    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
536    client_id: Option<i32>,
537    /// Push notification channel URI; may be empty to deregister a device
538
539    #[serde(default)]
540    channel_uri: String,
541}
542
543impl RObject for DeviceTokenMicrosoftPushVoIP {
544    #[doc(hidden)]
545    fn extra(&self) -> Option<&str> {
546        self.extra.as_deref()
547    }
548    #[doc(hidden)]
549    fn client_id(&self) -> Option<i32> {
550        self.client_id
551    }
552}
553
554impl TDDeviceToken for DeviceTokenMicrosoftPushVoIP {}
555
556impl DeviceTokenMicrosoftPushVoIP {
557    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
558        Ok(serde_json::from_str(json.as_ref())?)
559    }
560    pub fn builder() -> DeviceTokenMicrosoftPushVoIPBuilder {
561        let mut inner = DeviceTokenMicrosoftPushVoIP::default();
562        inner.extra = Some(Uuid::new_v4().to_string());
563
564        DeviceTokenMicrosoftPushVoIPBuilder { inner }
565    }
566
567    pub fn channel_uri(&self) -> &String {
568        &self.channel_uri
569    }
570}
571
572#[doc(hidden)]
573pub struct DeviceTokenMicrosoftPushVoIPBuilder {
574    inner: DeviceTokenMicrosoftPushVoIP,
575}
576
577#[deprecated]
578pub type RTDDeviceTokenMicrosoftPushVoIPBuilder = DeviceTokenMicrosoftPushVoIPBuilder;
579
580impl DeviceTokenMicrosoftPushVoIPBuilder {
581    pub fn build(&self) -> DeviceTokenMicrosoftPushVoIP {
582        self.inner.clone()
583    }
584
585    pub fn channel_uri<T: AsRef<str>>(&mut self, channel_uri: T) -> &mut Self {
586        self.inner.channel_uri = channel_uri.as_ref().to_string();
587        self
588    }
589}
590
591impl AsRef<DeviceTokenMicrosoftPushVoIP> for DeviceTokenMicrosoftPushVoIP {
592    fn as_ref(&self) -> &DeviceTokenMicrosoftPushVoIP {
593        self
594    }
595}
596
597impl AsRef<DeviceTokenMicrosoftPushVoIP> for DeviceTokenMicrosoftPushVoIPBuilder {
598    fn as_ref(&self) -> &DeviceTokenMicrosoftPushVoIP {
599        &self.inner
600    }
601}
602
603/// A token for Simple Push API for Firefox OS
604#[derive(Debug, Clone, Default, Serialize, Deserialize)]
605pub struct DeviceTokenSimplePush {
606    #[doc(hidden)]
607    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
608    extra: Option<String>,
609    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
610    client_id: Option<i32>,
611    /// Absolute URL exposed by the push service where the application server can send push messages; may be empty to deregister a device
612
613    #[serde(default)]
614    endpoint: String,
615}
616
617impl RObject for DeviceTokenSimplePush {
618    #[doc(hidden)]
619    fn extra(&self) -> Option<&str> {
620        self.extra.as_deref()
621    }
622    #[doc(hidden)]
623    fn client_id(&self) -> Option<i32> {
624        self.client_id
625    }
626}
627
628impl TDDeviceToken for DeviceTokenSimplePush {}
629
630impl DeviceTokenSimplePush {
631    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
632        Ok(serde_json::from_str(json.as_ref())?)
633    }
634    pub fn builder() -> DeviceTokenSimplePushBuilder {
635        let mut inner = DeviceTokenSimplePush::default();
636        inner.extra = Some(Uuid::new_v4().to_string());
637
638        DeviceTokenSimplePushBuilder { inner }
639    }
640
641    pub fn endpoint(&self) -> &String {
642        &self.endpoint
643    }
644}
645
646#[doc(hidden)]
647pub struct DeviceTokenSimplePushBuilder {
648    inner: DeviceTokenSimplePush,
649}
650
651#[deprecated]
652pub type RTDDeviceTokenSimplePushBuilder = DeviceTokenSimplePushBuilder;
653
654impl DeviceTokenSimplePushBuilder {
655    pub fn build(&self) -> DeviceTokenSimplePush {
656        self.inner.clone()
657    }
658
659    pub fn endpoint<T: AsRef<str>>(&mut self, endpoint: T) -> &mut Self {
660        self.inner.endpoint = endpoint.as_ref().to_string();
661        self
662    }
663}
664
665impl AsRef<DeviceTokenSimplePush> for DeviceTokenSimplePush {
666    fn as_ref(&self) -> &DeviceTokenSimplePush {
667        self
668    }
669}
670
671impl AsRef<DeviceTokenSimplePush> for DeviceTokenSimplePushBuilder {
672    fn as_ref(&self) -> &DeviceTokenSimplePush {
673        &self.inner
674    }
675}
676
677/// A token for Tizen Push Service
678#[derive(Debug, Clone, Default, Serialize, Deserialize)]
679pub struct DeviceTokenTizenPush {
680    #[doc(hidden)]
681    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
682    extra: Option<String>,
683    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
684    client_id: Option<i32>,
685    /// Push service registration identifier; may be empty to deregister a device
686
687    #[serde(default)]
688    reg_id: String,
689}
690
691impl RObject for DeviceTokenTizenPush {
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 TDDeviceToken for DeviceTokenTizenPush {}
703
704impl DeviceTokenTizenPush {
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() -> DeviceTokenTizenPushBuilder {
709        let mut inner = DeviceTokenTizenPush::default();
710        inner.extra = Some(Uuid::new_v4().to_string());
711
712        DeviceTokenTizenPushBuilder { inner }
713    }
714
715    pub fn reg_id(&self) -> &String {
716        &self.reg_id
717    }
718}
719
720#[doc(hidden)]
721pub struct DeviceTokenTizenPushBuilder {
722    inner: DeviceTokenTizenPush,
723}
724
725#[deprecated]
726pub type RTDDeviceTokenTizenPushBuilder = DeviceTokenTizenPushBuilder;
727
728impl DeviceTokenTizenPushBuilder {
729    pub fn build(&self) -> DeviceTokenTizenPush {
730        self.inner.clone()
731    }
732
733    pub fn reg_id<T: AsRef<str>>(&mut self, reg_id: T) -> &mut Self {
734        self.inner.reg_id = reg_id.as_ref().to_string();
735        self
736    }
737}
738
739impl AsRef<DeviceTokenTizenPush> for DeviceTokenTizenPush {
740    fn as_ref(&self) -> &DeviceTokenTizenPush {
741        self
742    }
743}
744
745impl AsRef<DeviceTokenTizenPush> for DeviceTokenTizenPushBuilder {
746    fn as_ref(&self) -> &DeviceTokenTizenPush {
747        &self.inner
748    }
749}
750
751/// A token for Ubuntu Push Client service
752#[derive(Debug, Clone, Default, Serialize, Deserialize)]
753pub struct DeviceTokenUbuntuPush {
754    #[doc(hidden)]
755    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
756    extra: Option<String>,
757    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
758    client_id: Option<i32>,
759    /// Token; may be empty to deregister a device
760
761    #[serde(default)]
762    token: String,
763}
764
765impl RObject for DeviceTokenUbuntuPush {
766    #[doc(hidden)]
767    fn extra(&self) -> Option<&str> {
768        self.extra.as_deref()
769    }
770    #[doc(hidden)]
771    fn client_id(&self) -> Option<i32> {
772        self.client_id
773    }
774}
775
776impl TDDeviceToken for DeviceTokenUbuntuPush {}
777
778impl DeviceTokenUbuntuPush {
779    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
780        Ok(serde_json::from_str(json.as_ref())?)
781    }
782    pub fn builder() -> DeviceTokenUbuntuPushBuilder {
783        let mut inner = DeviceTokenUbuntuPush::default();
784        inner.extra = Some(Uuid::new_v4().to_string());
785
786        DeviceTokenUbuntuPushBuilder { inner }
787    }
788
789    pub fn token(&self) -> &String {
790        &self.token
791    }
792}
793
794#[doc(hidden)]
795pub struct DeviceTokenUbuntuPushBuilder {
796    inner: DeviceTokenUbuntuPush,
797}
798
799#[deprecated]
800pub type RTDDeviceTokenUbuntuPushBuilder = DeviceTokenUbuntuPushBuilder;
801
802impl DeviceTokenUbuntuPushBuilder {
803    pub fn build(&self) -> DeviceTokenUbuntuPush {
804        self.inner.clone()
805    }
806
807    pub fn token<T: AsRef<str>>(&mut self, token: T) -> &mut Self {
808        self.inner.token = token.as_ref().to_string();
809        self
810    }
811}
812
813impl AsRef<DeviceTokenUbuntuPush> for DeviceTokenUbuntuPush {
814    fn as_ref(&self) -> &DeviceTokenUbuntuPush {
815        self
816    }
817}
818
819impl AsRef<DeviceTokenUbuntuPush> for DeviceTokenUbuntuPushBuilder {
820    fn as_ref(&self) -> &DeviceTokenUbuntuPush {
821        &self.inner
822    }
823}
824
825/// A token for web Push API
826#[derive(Debug, Clone, Default, Serialize, Deserialize)]
827pub struct DeviceTokenWebPush {
828    #[doc(hidden)]
829    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
830    extra: Option<String>,
831    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
832    client_id: Option<i32>,
833    /// Absolute URL exposed by the push service where the application server can send push messages; may be empty to deregister a device
834
835    #[serde(default)]
836    endpoint: String,
837    /// Base64url-encoded P-256 elliptic curve Diffie-Hellman public key
838
839    #[serde(default)]
840    p256dh_base64url: String,
841    /// Base64url-encoded authentication secret
842
843    #[serde(default)]
844    auth_base64url: String,
845}
846
847impl RObject for DeviceTokenWebPush {
848    #[doc(hidden)]
849    fn extra(&self) -> Option<&str> {
850        self.extra.as_deref()
851    }
852    #[doc(hidden)]
853    fn client_id(&self) -> Option<i32> {
854        self.client_id
855    }
856}
857
858impl TDDeviceToken for DeviceTokenWebPush {}
859
860impl DeviceTokenWebPush {
861    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
862        Ok(serde_json::from_str(json.as_ref())?)
863    }
864    pub fn builder() -> DeviceTokenWebPushBuilder {
865        let mut inner = DeviceTokenWebPush::default();
866        inner.extra = Some(Uuid::new_v4().to_string());
867
868        DeviceTokenWebPushBuilder { inner }
869    }
870
871    pub fn endpoint(&self) -> &String {
872        &self.endpoint
873    }
874
875    pub fn p256dh_base64url(&self) -> &String {
876        &self.p256dh_base64url
877    }
878
879    pub fn auth_base64url(&self) -> &String {
880        &self.auth_base64url
881    }
882}
883
884#[doc(hidden)]
885pub struct DeviceTokenWebPushBuilder {
886    inner: DeviceTokenWebPush,
887}
888
889#[deprecated]
890pub type RTDDeviceTokenWebPushBuilder = DeviceTokenWebPushBuilder;
891
892impl DeviceTokenWebPushBuilder {
893    pub fn build(&self) -> DeviceTokenWebPush {
894        self.inner.clone()
895    }
896
897    pub fn endpoint<T: AsRef<str>>(&mut self, endpoint: T) -> &mut Self {
898        self.inner.endpoint = endpoint.as_ref().to_string();
899        self
900    }
901
902    pub fn p256dh_base64url<T: AsRef<str>>(&mut self, p256dh_base64url: T) -> &mut Self {
903        self.inner.p256dh_base64url = p256dh_base64url.as_ref().to_string();
904        self
905    }
906
907    pub fn auth_base64url<T: AsRef<str>>(&mut self, auth_base64url: T) -> &mut Self {
908        self.inner.auth_base64url = auth_base64url.as_ref().to_string();
909        self
910    }
911}
912
913impl AsRef<DeviceTokenWebPush> for DeviceTokenWebPush {
914    fn as_ref(&self) -> &DeviceTokenWebPush {
915        self
916    }
917}
918
919impl AsRef<DeviceTokenWebPush> for DeviceTokenWebPushBuilder {
920    fn as_ref(&self) -> &DeviceTokenWebPush {
921        &self.inner
922    }
923}
924
925/// A token for Windows Push Notification Services
926#[derive(Debug, Clone, Default, Serialize, Deserialize)]
927pub struct DeviceTokenWindowsPush {
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    /// The access token that will be used to send notifications; may be empty to deregister a device
934
935    #[serde(default)]
936    access_token: String,
937}
938
939impl RObject for DeviceTokenWindowsPush {
940    #[doc(hidden)]
941    fn extra(&self) -> Option<&str> {
942        self.extra.as_deref()
943    }
944    #[doc(hidden)]
945    fn client_id(&self) -> Option<i32> {
946        self.client_id
947    }
948}
949
950impl TDDeviceToken for DeviceTokenWindowsPush {}
951
952impl DeviceTokenWindowsPush {
953    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
954        Ok(serde_json::from_str(json.as_ref())?)
955    }
956    pub fn builder() -> DeviceTokenWindowsPushBuilder {
957        let mut inner = DeviceTokenWindowsPush::default();
958        inner.extra = Some(Uuid::new_v4().to_string());
959
960        DeviceTokenWindowsPushBuilder { inner }
961    }
962
963    pub fn access_token(&self) -> &String {
964        &self.access_token
965    }
966}
967
968#[doc(hidden)]
969pub struct DeviceTokenWindowsPushBuilder {
970    inner: DeviceTokenWindowsPush,
971}
972
973#[deprecated]
974pub type RTDDeviceTokenWindowsPushBuilder = DeviceTokenWindowsPushBuilder;
975
976impl DeviceTokenWindowsPushBuilder {
977    pub fn build(&self) -> DeviceTokenWindowsPush {
978        self.inner.clone()
979    }
980
981    pub fn access_token<T: AsRef<str>>(&mut self, access_token: T) -> &mut Self {
982        self.inner.access_token = access_token.as_ref().to_string();
983        self
984    }
985}
986
987impl AsRef<DeviceTokenWindowsPush> for DeviceTokenWindowsPush {
988    fn as_ref(&self) -> &DeviceTokenWindowsPush {
989        self
990    }
991}
992
993impl AsRef<DeviceTokenWindowsPush> for DeviceTokenWindowsPushBuilder {
994    fn as_ref(&self) -> &DeviceTokenWindowsPush {
995        &self.inner
996    }
997}
rust_tdlib/types/device_token.rs

rust_tdlib/types/
device_token.rs
