rust_tdlib/types/
chat_member_status.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Provides information about the status of a member in a chat
8pub trait TDChatMemberStatus: Debug + RObject {}
9
10/// Provides information about the status of a member in a chat
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum ChatMemberStatus {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// The user is a member of the chat and has some additional privileges. In basic groups, administrators can edit and delete messages sent by others, add new members, ban unprivileged members, and manage video chats. In supergroups and channels, there are more detailed options for administrator privileges
18    #[serde(rename = "chatMemberStatusAdministrator")]
19    Administrator(ChatMemberStatusAdministrator),
20    /// The user or the chat was banned (and hence is not a member of the chat). Implies the user can't return to the chat, view messages, or be used as a participant identifier to join a video chat of the chat
21    #[serde(rename = "chatMemberStatusBanned")]
22    Banned(ChatMemberStatusBanned),
23    /// The user is the owner of the chat and has all the administrator privileges
24    #[serde(rename = "chatMemberStatusCreator")]
25    Creator(ChatMemberStatusCreator),
26    /// The user or the chat is not a chat member
27    #[serde(rename = "chatMemberStatusLeft")]
28    Left(ChatMemberStatusLeft),
29    /// The user is a member of the chat, without any additional privileges or restrictions
30    #[serde(rename = "chatMemberStatusMember")]
31    Member(ChatMemberStatusMember),
32    /// The user is under certain restrictions in the chat. Not supported in basic groups and channels
33    #[serde(rename = "chatMemberStatusRestricted")]
34    Restricted(ChatMemberStatusRestricted),
35}
36
37impl RObject for ChatMemberStatus {
38    #[doc(hidden)]
39    fn extra(&self) -> Option<&str> {
40        match self {
41            ChatMemberStatus::Administrator(t) => t.extra(),
42            ChatMemberStatus::Banned(t) => t.extra(),
43            ChatMemberStatus::Creator(t) => t.extra(),
44            ChatMemberStatus::Left(t) => t.extra(),
45            ChatMemberStatus::Member(t) => t.extra(),
46            ChatMemberStatus::Restricted(t) => t.extra(),
47
48            _ => None,
49        }
50    }
51    #[doc(hidden)]
52    fn client_id(&self) -> Option<i32> {
53        match self {
54            ChatMemberStatus::Administrator(t) => t.client_id(),
55            ChatMemberStatus::Banned(t) => t.client_id(),
56            ChatMemberStatus::Creator(t) => t.client_id(),
57            ChatMemberStatus::Left(t) => t.client_id(),
58            ChatMemberStatus::Member(t) => t.client_id(),
59            ChatMemberStatus::Restricted(t) => t.client_id(),
60
61            _ => None,
62        }
63    }
64}
65
66impl ChatMemberStatus {
67    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
68        Ok(serde_json::from_str(json.as_ref())?)
69    }
70    #[doc(hidden)]
71    pub fn _is_default(&self) -> bool {
72        matches!(self, ChatMemberStatus::_Default)
73    }
74}
75
76impl AsRef<ChatMemberStatus> for ChatMemberStatus {
77    fn as_ref(&self) -> &ChatMemberStatus {
78        self
79    }
80}
81
82/// The user is a member of the chat and has some additional privileges. In basic groups, administrators can edit and delete messages sent by others, add new members, ban unprivileged members, and manage video chats. In supergroups and channels, there are more detailed options for administrator privileges
83#[derive(Debug, Clone, Default, Serialize, Deserialize)]
84pub struct ChatMemberStatusAdministrator {
85    #[doc(hidden)]
86    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
87    extra: Option<String>,
88    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
89    client_id: Option<i32>,
90    /// A custom title of the administrator; 0-16 characters without emojis; applicable to supergroups only
91
92    #[serde(default)]
93    custom_title: String,
94    /// True, if the current user can edit the administrator privileges for the called user
95
96    #[serde(default)]
97    can_be_edited: bool,
98    /// True, if the administrator can get chat event log, get chat statistics, get message statistics in channels, get channel members, see anonymous administrators in supergroups and ignore slow mode. Implied by any other privilege; applicable to supergroups and channels only
99
100    #[serde(default)]
101    can_manage_chat: bool,
102    /// True, if the administrator can change the chat title, photo, and other settings
103
104    #[serde(default)]
105    can_change_info: bool,
106    /// True, if the administrator can create channel posts; applicable to channels only
107
108    #[serde(default)]
109    can_post_messages: bool,
110    /// True, if the administrator can edit messages of other users and pin messages; applicable to channels only
111
112    #[serde(default)]
113    can_edit_messages: bool,
114    /// True, if the administrator can delete messages of other users
115
116    #[serde(default)]
117    can_delete_messages: bool,
118    /// True, if the administrator can invite new users to the chat
119
120    #[serde(default)]
121    can_invite_users: bool,
122    /// True, if the administrator can restrict, ban, or unban chat members; always true for channels
123
124    #[serde(default)]
125    can_restrict_members: bool,
126    /// True, if the administrator can pin messages; applicable to basic groups and supergroups only
127
128    #[serde(default)]
129    can_pin_messages: bool,
130    /// True, if the administrator can add new administrators with a subset of their own privileges or demote administrators that were directly or indirectly promoted by them
131
132    #[serde(default)]
133    can_promote_members: bool,
134    /// True, if the administrator can manage video chats
135
136    #[serde(default)]
137    can_manage_video_chats: bool,
138    /// True, if the administrator isn't shown in the chat member list and sends messages anonymously; applicable to supergroups only
139
140    #[serde(default)]
141    is_anonymous: bool,
142}
143
144impl RObject for ChatMemberStatusAdministrator {
145    #[doc(hidden)]
146    fn extra(&self) -> Option<&str> {
147        self.extra.as_deref()
148    }
149    #[doc(hidden)]
150    fn client_id(&self) -> Option<i32> {
151        self.client_id
152    }
153}
154
155impl TDChatMemberStatus for ChatMemberStatusAdministrator {}
156
157impl ChatMemberStatusAdministrator {
158    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
159        Ok(serde_json::from_str(json.as_ref())?)
160    }
161    pub fn builder() -> ChatMemberStatusAdministratorBuilder {
162        let mut inner = ChatMemberStatusAdministrator::default();
163        inner.extra = Some(Uuid::new_v4().to_string());
164
165        ChatMemberStatusAdministratorBuilder { inner }
166    }
167
168    pub fn custom_title(&self) -> &String {
169        &self.custom_title
170    }
171
172    pub fn can_be_edited(&self) -> bool {
173        self.can_be_edited
174    }
175
176    pub fn can_manage_chat(&self) -> bool {
177        self.can_manage_chat
178    }
179
180    pub fn can_change_info(&self) -> bool {
181        self.can_change_info
182    }
183
184    pub fn can_post_messages(&self) -> bool {
185        self.can_post_messages
186    }
187
188    pub fn can_edit_messages(&self) -> bool {
189        self.can_edit_messages
190    }
191
192    pub fn can_delete_messages(&self) -> bool {
193        self.can_delete_messages
194    }
195
196    pub fn can_invite_users(&self) -> bool {
197        self.can_invite_users
198    }
199
200    pub fn can_restrict_members(&self) -> bool {
201        self.can_restrict_members
202    }
203
204    pub fn can_pin_messages(&self) -> bool {
205        self.can_pin_messages
206    }
207
208    pub fn can_promote_members(&self) -> bool {
209        self.can_promote_members
210    }
211
212    pub fn can_manage_video_chats(&self) -> bool {
213        self.can_manage_video_chats
214    }
215
216    pub fn is_anonymous(&self) -> bool {
217        self.is_anonymous
218    }
219}
220
221#[doc(hidden)]
222pub struct ChatMemberStatusAdministratorBuilder {
223    inner: ChatMemberStatusAdministrator,
224}
225
226#[deprecated]
227pub type RTDChatMemberStatusAdministratorBuilder = ChatMemberStatusAdministratorBuilder;
228
229impl ChatMemberStatusAdministratorBuilder {
230    pub fn build(&self) -> ChatMemberStatusAdministrator {
231        self.inner.clone()
232    }
233
234    pub fn custom_title<T: AsRef<str>>(&mut self, custom_title: T) -> &mut Self {
235        self.inner.custom_title = custom_title.as_ref().to_string();
236        self
237    }
238
239    pub fn can_be_edited(&mut self, can_be_edited: bool) -> &mut Self {
240        self.inner.can_be_edited = can_be_edited;
241        self
242    }
243
244    pub fn can_manage_chat(&mut self, can_manage_chat: bool) -> &mut Self {
245        self.inner.can_manage_chat = can_manage_chat;
246        self
247    }
248
249    pub fn can_change_info(&mut self, can_change_info: bool) -> &mut Self {
250        self.inner.can_change_info = can_change_info;
251        self
252    }
253
254    pub fn can_post_messages(&mut self, can_post_messages: bool) -> &mut Self {
255        self.inner.can_post_messages = can_post_messages;
256        self
257    }
258
259    pub fn can_edit_messages(&mut self, can_edit_messages: bool) -> &mut Self {
260        self.inner.can_edit_messages = can_edit_messages;
261        self
262    }
263
264    pub fn can_delete_messages(&mut self, can_delete_messages: bool) -> &mut Self {
265        self.inner.can_delete_messages = can_delete_messages;
266        self
267    }
268
269    pub fn can_invite_users(&mut self, can_invite_users: bool) -> &mut Self {
270        self.inner.can_invite_users = can_invite_users;
271        self
272    }
273
274    pub fn can_restrict_members(&mut self, can_restrict_members: bool) -> &mut Self {
275        self.inner.can_restrict_members = can_restrict_members;
276        self
277    }
278
279    pub fn can_pin_messages(&mut self, can_pin_messages: bool) -> &mut Self {
280        self.inner.can_pin_messages = can_pin_messages;
281        self
282    }
283
284    pub fn can_promote_members(&mut self, can_promote_members: bool) -> &mut Self {
285        self.inner.can_promote_members = can_promote_members;
286        self
287    }
288
289    pub fn can_manage_video_chats(&mut self, can_manage_video_chats: bool) -> &mut Self {
290        self.inner.can_manage_video_chats = can_manage_video_chats;
291        self
292    }
293
294    pub fn is_anonymous(&mut self, is_anonymous: bool) -> &mut Self {
295        self.inner.is_anonymous = is_anonymous;
296        self
297    }
298}
299
300impl AsRef<ChatMemberStatusAdministrator> for ChatMemberStatusAdministrator {
301    fn as_ref(&self) -> &ChatMemberStatusAdministrator {
302        self
303    }
304}
305
306impl AsRef<ChatMemberStatusAdministrator> for ChatMemberStatusAdministratorBuilder {
307    fn as_ref(&self) -> &ChatMemberStatusAdministrator {
308        &self.inner
309    }
310}
311
312/// The user or the chat was banned (and hence is not a member of the chat). Implies the user can't return to the chat, view messages, or be used as a participant identifier to join a video chat of the chat
313#[derive(Debug, Clone, Default, Serialize, Deserialize)]
314pub struct ChatMemberStatusBanned {
315    #[doc(hidden)]
316    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
317    extra: Option<String>,
318    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
319    client_id: Option<i32>,
320    /// Point in time (Unix timestamp) when the user will be unbanned; 0 if never. If the user is banned for more than 366 days or for less than 30 seconds from the current time, the user is considered to be banned forever. Always 0 in basic groups
321
322    #[serde(default)]
323    banned_until_date: i32,
324}
325
326impl RObject for ChatMemberStatusBanned {
327    #[doc(hidden)]
328    fn extra(&self) -> Option<&str> {
329        self.extra.as_deref()
330    }
331    #[doc(hidden)]
332    fn client_id(&self) -> Option<i32> {
333        self.client_id
334    }
335}
336
337impl TDChatMemberStatus for ChatMemberStatusBanned {}
338
339impl ChatMemberStatusBanned {
340    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
341        Ok(serde_json::from_str(json.as_ref())?)
342    }
343    pub fn builder() -> ChatMemberStatusBannedBuilder {
344        let mut inner = ChatMemberStatusBanned::default();
345        inner.extra = Some(Uuid::new_v4().to_string());
346
347        ChatMemberStatusBannedBuilder { inner }
348    }
349
350    pub fn banned_until_date(&self) -> i32 {
351        self.banned_until_date
352    }
353}
354
355#[doc(hidden)]
356pub struct ChatMemberStatusBannedBuilder {
357    inner: ChatMemberStatusBanned,
358}
359
360#[deprecated]
361pub type RTDChatMemberStatusBannedBuilder = ChatMemberStatusBannedBuilder;
362
363impl ChatMemberStatusBannedBuilder {
364    pub fn build(&self) -> ChatMemberStatusBanned {
365        self.inner.clone()
366    }
367
368    pub fn banned_until_date(&mut self, banned_until_date: i32) -> &mut Self {
369        self.inner.banned_until_date = banned_until_date;
370        self
371    }
372}
373
374impl AsRef<ChatMemberStatusBanned> for ChatMemberStatusBanned {
375    fn as_ref(&self) -> &ChatMemberStatusBanned {
376        self
377    }
378}
379
380impl AsRef<ChatMemberStatusBanned> for ChatMemberStatusBannedBuilder {
381    fn as_ref(&self) -> &ChatMemberStatusBanned {
382        &self.inner
383    }
384}
385
386/// The user is the owner of the chat and has all the administrator privileges
387#[derive(Debug, Clone, Default, Serialize, Deserialize)]
388pub struct ChatMemberStatusCreator {
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    /// A custom title of the owner; 0-16 characters without emojis; applicable to supergroups only
395
396    #[serde(default)]
397    custom_title: String,
398    /// True, if the creator isn't shown in the chat member list and sends messages anonymously; applicable to supergroups only
399
400    #[serde(default)]
401    is_anonymous: bool,
402    /// True, if the user is a member of the chat
403
404    #[serde(default)]
405    is_member: bool,
406}
407
408impl RObject for ChatMemberStatusCreator {
409    #[doc(hidden)]
410    fn extra(&self) -> Option<&str> {
411        self.extra.as_deref()
412    }
413    #[doc(hidden)]
414    fn client_id(&self) -> Option<i32> {
415        self.client_id
416    }
417}
418
419impl TDChatMemberStatus for ChatMemberStatusCreator {}
420
421impl ChatMemberStatusCreator {
422    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
423        Ok(serde_json::from_str(json.as_ref())?)
424    }
425    pub fn builder() -> ChatMemberStatusCreatorBuilder {
426        let mut inner = ChatMemberStatusCreator::default();
427        inner.extra = Some(Uuid::new_v4().to_string());
428
429        ChatMemberStatusCreatorBuilder { inner }
430    }
431
432    pub fn custom_title(&self) -> &String {
433        &self.custom_title
434    }
435
436    pub fn is_anonymous(&self) -> bool {
437        self.is_anonymous
438    }
439
440    pub fn is_member(&self) -> bool {
441        self.is_member
442    }
443}
444
445#[doc(hidden)]
446pub struct ChatMemberStatusCreatorBuilder {
447    inner: ChatMemberStatusCreator,
448}
449
450#[deprecated]
451pub type RTDChatMemberStatusCreatorBuilder = ChatMemberStatusCreatorBuilder;
452
453impl ChatMemberStatusCreatorBuilder {
454    pub fn build(&self) -> ChatMemberStatusCreator {
455        self.inner.clone()
456    }
457
458    pub fn custom_title<T: AsRef<str>>(&mut self, custom_title: T) -> &mut Self {
459        self.inner.custom_title = custom_title.as_ref().to_string();
460        self
461    }
462
463    pub fn is_anonymous(&mut self, is_anonymous: bool) -> &mut Self {
464        self.inner.is_anonymous = is_anonymous;
465        self
466    }
467
468    pub fn is_member(&mut self, is_member: bool) -> &mut Self {
469        self.inner.is_member = is_member;
470        self
471    }
472}
473
474impl AsRef<ChatMemberStatusCreator> for ChatMemberStatusCreator {
475    fn as_ref(&self) -> &ChatMemberStatusCreator {
476        self
477    }
478}
479
480impl AsRef<ChatMemberStatusCreator> for ChatMemberStatusCreatorBuilder {
481    fn as_ref(&self) -> &ChatMemberStatusCreator {
482        &self.inner
483    }
484}
485
486/// The user or the chat is not a chat member
487#[derive(Debug, Clone, Default, Serialize, Deserialize)]
488pub struct ChatMemberStatusLeft {
489    #[doc(hidden)]
490    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
491    extra: Option<String>,
492    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
493    client_id: Option<i32>,
494}
495
496impl RObject for ChatMemberStatusLeft {
497    #[doc(hidden)]
498    fn extra(&self) -> Option<&str> {
499        self.extra.as_deref()
500    }
501    #[doc(hidden)]
502    fn client_id(&self) -> Option<i32> {
503        self.client_id
504    }
505}
506
507impl TDChatMemberStatus for ChatMemberStatusLeft {}
508
509impl ChatMemberStatusLeft {
510    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
511        Ok(serde_json::from_str(json.as_ref())?)
512    }
513    pub fn builder() -> ChatMemberStatusLeftBuilder {
514        let mut inner = ChatMemberStatusLeft::default();
515        inner.extra = Some(Uuid::new_v4().to_string());
516
517        ChatMemberStatusLeftBuilder { inner }
518    }
519}
520
521#[doc(hidden)]
522pub struct ChatMemberStatusLeftBuilder {
523    inner: ChatMemberStatusLeft,
524}
525
526#[deprecated]
527pub type RTDChatMemberStatusLeftBuilder = ChatMemberStatusLeftBuilder;
528
529impl ChatMemberStatusLeftBuilder {
530    pub fn build(&self) -> ChatMemberStatusLeft {
531        self.inner.clone()
532    }
533}
534
535impl AsRef<ChatMemberStatusLeft> for ChatMemberStatusLeft {
536    fn as_ref(&self) -> &ChatMemberStatusLeft {
537        self
538    }
539}
540
541impl AsRef<ChatMemberStatusLeft> for ChatMemberStatusLeftBuilder {
542    fn as_ref(&self) -> &ChatMemberStatusLeft {
543        &self.inner
544    }
545}
546
547/// The user is a member of the chat, without any additional privileges or restrictions
548#[derive(Debug, Clone, Default, Serialize, Deserialize)]
549pub struct ChatMemberStatusMember {
550    #[doc(hidden)]
551    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
552    extra: Option<String>,
553    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
554    client_id: Option<i32>,
555}
556
557impl RObject for ChatMemberStatusMember {
558    #[doc(hidden)]
559    fn extra(&self) -> Option<&str> {
560        self.extra.as_deref()
561    }
562    #[doc(hidden)]
563    fn client_id(&self) -> Option<i32> {
564        self.client_id
565    }
566}
567
568impl TDChatMemberStatus for ChatMemberStatusMember {}
569
570impl ChatMemberStatusMember {
571    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
572        Ok(serde_json::from_str(json.as_ref())?)
573    }
574    pub fn builder() -> ChatMemberStatusMemberBuilder {
575        let mut inner = ChatMemberStatusMember::default();
576        inner.extra = Some(Uuid::new_v4().to_string());
577
578        ChatMemberStatusMemberBuilder { inner }
579    }
580}
581
582#[doc(hidden)]
583pub struct ChatMemberStatusMemberBuilder {
584    inner: ChatMemberStatusMember,
585}
586
587#[deprecated]
588pub type RTDChatMemberStatusMemberBuilder = ChatMemberStatusMemberBuilder;
589
590impl ChatMemberStatusMemberBuilder {
591    pub fn build(&self) -> ChatMemberStatusMember {
592        self.inner.clone()
593    }
594}
595
596impl AsRef<ChatMemberStatusMember> for ChatMemberStatusMember {
597    fn as_ref(&self) -> &ChatMemberStatusMember {
598        self
599    }
600}
601
602impl AsRef<ChatMemberStatusMember> for ChatMemberStatusMemberBuilder {
603    fn as_ref(&self) -> &ChatMemberStatusMember {
604        &self.inner
605    }
606}
607
608/// The user is under certain restrictions in the chat. Not supported in basic groups and channels
609#[derive(Debug, Clone, Default, Serialize, Deserialize)]
610pub struct ChatMemberStatusRestricted {
611    #[doc(hidden)]
612    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
613    extra: Option<String>,
614    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
615    client_id: Option<i32>,
616    /// True, if the user is a member of the chat
617
618    #[serde(default)]
619    is_member: bool,
620    /// Point in time (Unix timestamp) when restrictions will be lifted from the user; 0 if never. If the user is restricted for more than 366 days or for less than 30 seconds from the current time, the user is considered to be restricted forever
621
622    #[serde(default)]
623    restricted_until_date: i32,
624    /// User permissions in the chat
625    permissions: ChatPermissions,
626}
627
628impl RObject for ChatMemberStatusRestricted {
629    #[doc(hidden)]
630    fn extra(&self) -> Option<&str> {
631        self.extra.as_deref()
632    }
633    #[doc(hidden)]
634    fn client_id(&self) -> Option<i32> {
635        self.client_id
636    }
637}
638
639impl TDChatMemberStatus for ChatMemberStatusRestricted {}
640
641impl ChatMemberStatusRestricted {
642    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
643        Ok(serde_json::from_str(json.as_ref())?)
644    }
645    pub fn builder() -> ChatMemberStatusRestrictedBuilder {
646        let mut inner = ChatMemberStatusRestricted::default();
647        inner.extra = Some(Uuid::new_v4().to_string());
648
649        ChatMemberStatusRestrictedBuilder { inner }
650    }
651
652    pub fn is_member(&self) -> bool {
653        self.is_member
654    }
655
656    pub fn restricted_until_date(&self) -> i32 {
657        self.restricted_until_date
658    }
659
660    pub fn permissions(&self) -> &ChatPermissions {
661        &self.permissions
662    }
663}
664
665#[doc(hidden)]
666pub struct ChatMemberStatusRestrictedBuilder {
667    inner: ChatMemberStatusRestricted,
668}
669
670#[deprecated]
671pub type RTDChatMemberStatusRestrictedBuilder = ChatMemberStatusRestrictedBuilder;
672
673impl ChatMemberStatusRestrictedBuilder {
674    pub fn build(&self) -> ChatMemberStatusRestricted {
675        self.inner.clone()
676    }
677
678    pub fn is_member(&mut self, is_member: bool) -> &mut Self {
679        self.inner.is_member = is_member;
680        self
681    }
682
683    pub fn restricted_until_date(&mut self, restricted_until_date: i32) -> &mut Self {
684        self.inner.restricted_until_date = restricted_until_date;
685        self
686    }
687
688    pub fn permissions<T: AsRef<ChatPermissions>>(&mut self, permissions: T) -> &mut Self {
689        self.inner.permissions = permissions.as_ref().clone();
690        self
691    }
692}
693
694impl AsRef<ChatMemberStatusRestricted> for ChatMemberStatusRestricted {
695    fn as_ref(&self) -> &ChatMemberStatusRestricted {
696        self
697    }
698}
699
700impl AsRef<ChatMemberStatusRestricted> for ChatMemberStatusRestrictedBuilder {
701    fn as_ref(&self) -> &ChatMemberStatusRestricted {
702        &self.inner
703    }
704}
rust_tdlib/types/chat_member_status.rs

rust_tdlib/types/
chat_member_status.rs
