rust_tdlib/types/
user_privacy_setting_rule.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Represents a single rule for managing privacy settings
8pub trait TDUserPrivacySettingRule: Debug + RObject {}
9
10/// Represents a single rule for managing privacy settings
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum UserPrivacySettingRule {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// A rule to allow all users to do something
18    #[serde(rename = "userPrivacySettingRuleAllowAll")]
19    AllowAll(UserPrivacySettingRuleAllowAll),
20    /// A rule to allow all members of certain specified basic groups and supergroups to doing something
21    #[serde(rename = "userPrivacySettingRuleAllowChatMembers")]
22    AllowChatMembers(UserPrivacySettingRuleAllowChatMembers),
23    /// A rule to allow all of a user's contacts to do something
24    #[serde(rename = "userPrivacySettingRuleAllowContacts")]
25    AllowContacts(UserPrivacySettingRuleAllowContacts),
26    /// A rule to allow certain specified users to do something
27    #[serde(rename = "userPrivacySettingRuleAllowUsers")]
28    AllowUsers(UserPrivacySettingRuleAllowUsers),
29    /// A rule to restrict all users from doing something
30    #[serde(rename = "userPrivacySettingRuleRestrictAll")]
31    RestrictAll(UserPrivacySettingRuleRestrictAll),
32    /// A rule to restrict all members of specified basic groups and supergroups from doing something
33    #[serde(rename = "userPrivacySettingRuleRestrictChatMembers")]
34    RestrictChatMembers(UserPrivacySettingRuleRestrictChatMembers),
35    /// A rule to restrict all contacts of a user from doing something
36    #[serde(rename = "userPrivacySettingRuleRestrictContacts")]
37    RestrictContacts(UserPrivacySettingRuleRestrictContacts),
38    /// A rule to restrict all specified users from doing something
39    #[serde(rename = "userPrivacySettingRuleRestrictUsers")]
40    RestrictUsers(UserPrivacySettingRuleRestrictUsers),
41}
42
43impl RObject for UserPrivacySettingRule {
44    #[doc(hidden)]
45    fn extra(&self) -> Option<&str> {
46        match self {
47            UserPrivacySettingRule::AllowAll(t) => t.extra(),
48            UserPrivacySettingRule::AllowChatMembers(t) => t.extra(),
49            UserPrivacySettingRule::AllowContacts(t) => t.extra(),
50            UserPrivacySettingRule::AllowUsers(t) => t.extra(),
51            UserPrivacySettingRule::RestrictAll(t) => t.extra(),
52            UserPrivacySettingRule::RestrictChatMembers(t) => t.extra(),
53            UserPrivacySettingRule::RestrictContacts(t) => t.extra(),
54            UserPrivacySettingRule::RestrictUsers(t) => t.extra(),
55
56            _ => None,
57        }
58    }
59    #[doc(hidden)]
60    fn client_id(&self) -> Option<i32> {
61        match self {
62            UserPrivacySettingRule::AllowAll(t) => t.client_id(),
63            UserPrivacySettingRule::AllowChatMembers(t) => t.client_id(),
64            UserPrivacySettingRule::AllowContacts(t) => t.client_id(),
65            UserPrivacySettingRule::AllowUsers(t) => t.client_id(),
66            UserPrivacySettingRule::RestrictAll(t) => t.client_id(),
67            UserPrivacySettingRule::RestrictChatMembers(t) => t.client_id(),
68            UserPrivacySettingRule::RestrictContacts(t) => t.client_id(),
69            UserPrivacySettingRule::RestrictUsers(t) => t.client_id(),
70
71            _ => None,
72        }
73    }
74}
75
76impl UserPrivacySettingRule {
77    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
78        Ok(serde_json::from_str(json.as_ref())?)
79    }
80    #[doc(hidden)]
81    pub fn _is_default(&self) -> bool {
82        matches!(self, UserPrivacySettingRule::_Default)
83    }
84}
85
86impl AsRef<UserPrivacySettingRule> for UserPrivacySettingRule {
87    fn as_ref(&self) -> &UserPrivacySettingRule {
88        self
89    }
90}
91
92/// A rule to allow all users to do something
93#[derive(Debug, Clone, Default, Serialize, Deserialize)]
94pub struct UserPrivacySettingRuleAllowAll {
95    #[doc(hidden)]
96    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
97    extra: Option<String>,
98    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
99    client_id: Option<i32>,
100}
101
102impl RObject for UserPrivacySettingRuleAllowAll {
103    #[doc(hidden)]
104    fn extra(&self) -> Option<&str> {
105        self.extra.as_deref()
106    }
107    #[doc(hidden)]
108    fn client_id(&self) -> Option<i32> {
109        self.client_id
110    }
111}
112
113impl TDUserPrivacySettingRule for UserPrivacySettingRuleAllowAll {}
114
115impl UserPrivacySettingRuleAllowAll {
116    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
117        Ok(serde_json::from_str(json.as_ref())?)
118    }
119    pub fn builder() -> UserPrivacySettingRuleAllowAllBuilder {
120        let mut inner = UserPrivacySettingRuleAllowAll::default();
121        inner.extra = Some(Uuid::new_v4().to_string());
122
123        UserPrivacySettingRuleAllowAllBuilder { inner }
124    }
125}
126
127#[doc(hidden)]
128pub struct UserPrivacySettingRuleAllowAllBuilder {
129    inner: UserPrivacySettingRuleAllowAll,
130}
131
132#[deprecated]
133pub type RTDUserPrivacySettingRuleAllowAllBuilder = UserPrivacySettingRuleAllowAllBuilder;
134
135impl UserPrivacySettingRuleAllowAllBuilder {
136    pub fn build(&self) -> UserPrivacySettingRuleAllowAll {
137        self.inner.clone()
138    }
139}
140
141impl AsRef<UserPrivacySettingRuleAllowAll> for UserPrivacySettingRuleAllowAll {
142    fn as_ref(&self) -> &UserPrivacySettingRuleAllowAll {
143        self
144    }
145}
146
147impl AsRef<UserPrivacySettingRuleAllowAll> for UserPrivacySettingRuleAllowAllBuilder {
148    fn as_ref(&self) -> &UserPrivacySettingRuleAllowAll {
149        &self.inner
150    }
151}
152
153/// A rule to allow all members of certain specified basic groups and supergroups to doing something
154#[derive(Debug, Clone, Default, Serialize, Deserialize)]
155pub struct UserPrivacySettingRuleAllowChatMembers {
156    #[doc(hidden)]
157    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
158    extra: Option<String>,
159    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
160    client_id: Option<i32>,
161    /// The chat identifiers, total number of chats in all rules must not exceed 20
162
163    #[serde(default)]
164    chat_ids: Vec<i64>,
165}
166
167impl RObject for UserPrivacySettingRuleAllowChatMembers {
168    #[doc(hidden)]
169    fn extra(&self) -> Option<&str> {
170        self.extra.as_deref()
171    }
172    #[doc(hidden)]
173    fn client_id(&self) -> Option<i32> {
174        self.client_id
175    }
176}
177
178impl TDUserPrivacySettingRule for UserPrivacySettingRuleAllowChatMembers {}
179
180impl UserPrivacySettingRuleAllowChatMembers {
181    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
182        Ok(serde_json::from_str(json.as_ref())?)
183    }
184    pub fn builder() -> UserPrivacySettingRuleAllowChatMembersBuilder {
185        let mut inner = UserPrivacySettingRuleAllowChatMembers::default();
186        inner.extra = Some(Uuid::new_v4().to_string());
187
188        UserPrivacySettingRuleAllowChatMembersBuilder { inner }
189    }
190
191    pub fn chat_ids(&self) -> &Vec<i64> {
192        &self.chat_ids
193    }
194}
195
196#[doc(hidden)]
197pub struct UserPrivacySettingRuleAllowChatMembersBuilder {
198    inner: UserPrivacySettingRuleAllowChatMembers,
199}
200
201#[deprecated]
202pub type RTDUserPrivacySettingRuleAllowChatMembersBuilder =
203    UserPrivacySettingRuleAllowChatMembersBuilder;
204
205impl UserPrivacySettingRuleAllowChatMembersBuilder {
206    pub fn build(&self) -> UserPrivacySettingRuleAllowChatMembers {
207        self.inner.clone()
208    }
209
210    pub fn chat_ids(&mut self, chat_ids: Vec<i64>) -> &mut Self {
211        self.inner.chat_ids = chat_ids;
212        self
213    }
214}
215
216impl AsRef<UserPrivacySettingRuleAllowChatMembers> for UserPrivacySettingRuleAllowChatMembers {
217    fn as_ref(&self) -> &UserPrivacySettingRuleAllowChatMembers {
218        self
219    }
220}
221
222impl AsRef<UserPrivacySettingRuleAllowChatMembers>
223    for UserPrivacySettingRuleAllowChatMembersBuilder
224{
225    fn as_ref(&self) -> &UserPrivacySettingRuleAllowChatMembers {
226        &self.inner
227    }
228}
229
230/// A rule to allow all of a user's contacts to do something
231#[derive(Debug, Clone, Default, Serialize, Deserialize)]
232pub struct UserPrivacySettingRuleAllowContacts {
233    #[doc(hidden)]
234    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
235    extra: Option<String>,
236    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
237    client_id: Option<i32>,
238}
239
240impl RObject for UserPrivacySettingRuleAllowContacts {
241    #[doc(hidden)]
242    fn extra(&self) -> Option<&str> {
243        self.extra.as_deref()
244    }
245    #[doc(hidden)]
246    fn client_id(&self) -> Option<i32> {
247        self.client_id
248    }
249}
250
251impl TDUserPrivacySettingRule for UserPrivacySettingRuleAllowContacts {}
252
253impl UserPrivacySettingRuleAllowContacts {
254    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
255        Ok(serde_json::from_str(json.as_ref())?)
256    }
257    pub fn builder() -> UserPrivacySettingRuleAllowContactsBuilder {
258        let mut inner = UserPrivacySettingRuleAllowContacts::default();
259        inner.extra = Some(Uuid::new_v4().to_string());
260
261        UserPrivacySettingRuleAllowContactsBuilder { inner }
262    }
263}
264
265#[doc(hidden)]
266pub struct UserPrivacySettingRuleAllowContactsBuilder {
267    inner: UserPrivacySettingRuleAllowContacts,
268}
269
270#[deprecated]
271pub type RTDUserPrivacySettingRuleAllowContactsBuilder = UserPrivacySettingRuleAllowContactsBuilder;
272
273impl UserPrivacySettingRuleAllowContactsBuilder {
274    pub fn build(&self) -> UserPrivacySettingRuleAllowContacts {
275        self.inner.clone()
276    }
277}
278
279impl AsRef<UserPrivacySettingRuleAllowContacts> for UserPrivacySettingRuleAllowContacts {
280    fn as_ref(&self) -> &UserPrivacySettingRuleAllowContacts {
281        self
282    }
283}
284
285impl AsRef<UserPrivacySettingRuleAllowContacts> for UserPrivacySettingRuleAllowContactsBuilder {
286    fn as_ref(&self) -> &UserPrivacySettingRuleAllowContacts {
287        &self.inner
288    }
289}
290
291/// A rule to allow certain specified users to do something
292#[derive(Debug, Clone, Default, Serialize, Deserialize)]
293pub struct UserPrivacySettingRuleAllowUsers {
294    #[doc(hidden)]
295    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
296    extra: Option<String>,
297    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
298    client_id: Option<i32>,
299    /// The user identifiers, total number of users in all rules must not exceed 1000
300
301    #[serde(default)]
302    user_ids: Vec<i64>,
303}
304
305impl RObject for UserPrivacySettingRuleAllowUsers {
306    #[doc(hidden)]
307    fn extra(&self) -> Option<&str> {
308        self.extra.as_deref()
309    }
310    #[doc(hidden)]
311    fn client_id(&self) -> Option<i32> {
312        self.client_id
313    }
314}
315
316impl TDUserPrivacySettingRule for UserPrivacySettingRuleAllowUsers {}
317
318impl UserPrivacySettingRuleAllowUsers {
319    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
320        Ok(serde_json::from_str(json.as_ref())?)
321    }
322    pub fn builder() -> UserPrivacySettingRuleAllowUsersBuilder {
323        let mut inner = UserPrivacySettingRuleAllowUsers::default();
324        inner.extra = Some(Uuid::new_v4().to_string());
325
326        UserPrivacySettingRuleAllowUsersBuilder { inner }
327    }
328
329    pub fn user_ids(&self) -> &Vec<i64> {
330        &self.user_ids
331    }
332}
333
334#[doc(hidden)]
335pub struct UserPrivacySettingRuleAllowUsersBuilder {
336    inner: UserPrivacySettingRuleAllowUsers,
337}
338
339#[deprecated]
340pub type RTDUserPrivacySettingRuleAllowUsersBuilder = UserPrivacySettingRuleAllowUsersBuilder;
341
342impl UserPrivacySettingRuleAllowUsersBuilder {
343    pub fn build(&self) -> UserPrivacySettingRuleAllowUsers {
344        self.inner.clone()
345    }
346
347    pub fn user_ids(&mut self, user_ids: Vec<i64>) -> &mut Self {
348        self.inner.user_ids = user_ids;
349        self
350    }
351}
352
353impl AsRef<UserPrivacySettingRuleAllowUsers> for UserPrivacySettingRuleAllowUsers {
354    fn as_ref(&self) -> &UserPrivacySettingRuleAllowUsers {
355        self
356    }
357}
358
359impl AsRef<UserPrivacySettingRuleAllowUsers> for UserPrivacySettingRuleAllowUsersBuilder {
360    fn as_ref(&self) -> &UserPrivacySettingRuleAllowUsers {
361        &self.inner
362    }
363}
364
365/// A rule to restrict all users from doing something
366#[derive(Debug, Clone, Default, Serialize, Deserialize)]
367pub struct UserPrivacySettingRuleRestrictAll {
368    #[doc(hidden)]
369    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
370    extra: Option<String>,
371    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
372    client_id: Option<i32>,
373}
374
375impl RObject for UserPrivacySettingRuleRestrictAll {
376    #[doc(hidden)]
377    fn extra(&self) -> Option<&str> {
378        self.extra.as_deref()
379    }
380    #[doc(hidden)]
381    fn client_id(&self) -> Option<i32> {
382        self.client_id
383    }
384}
385
386impl TDUserPrivacySettingRule for UserPrivacySettingRuleRestrictAll {}
387
388impl UserPrivacySettingRuleRestrictAll {
389    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
390        Ok(serde_json::from_str(json.as_ref())?)
391    }
392    pub fn builder() -> UserPrivacySettingRuleRestrictAllBuilder {
393        let mut inner = UserPrivacySettingRuleRestrictAll::default();
394        inner.extra = Some(Uuid::new_v4().to_string());
395
396        UserPrivacySettingRuleRestrictAllBuilder { inner }
397    }
398}
399
400#[doc(hidden)]
401pub struct UserPrivacySettingRuleRestrictAllBuilder {
402    inner: UserPrivacySettingRuleRestrictAll,
403}
404
405#[deprecated]
406pub type RTDUserPrivacySettingRuleRestrictAllBuilder = UserPrivacySettingRuleRestrictAllBuilder;
407
408impl UserPrivacySettingRuleRestrictAllBuilder {
409    pub fn build(&self) -> UserPrivacySettingRuleRestrictAll {
410        self.inner.clone()
411    }
412}
413
414impl AsRef<UserPrivacySettingRuleRestrictAll> for UserPrivacySettingRuleRestrictAll {
415    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictAll {
416        self
417    }
418}
419
420impl AsRef<UserPrivacySettingRuleRestrictAll> for UserPrivacySettingRuleRestrictAllBuilder {
421    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictAll {
422        &self.inner
423    }
424}
425
426/// A rule to restrict all members of specified basic groups and supergroups from doing something
427#[derive(Debug, Clone, Default, Serialize, Deserialize)]
428pub struct UserPrivacySettingRuleRestrictChatMembers {
429    #[doc(hidden)]
430    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
431    extra: Option<String>,
432    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
433    client_id: Option<i32>,
434    /// The chat identifiers, total number of chats in all rules must not exceed 20
435
436    #[serde(default)]
437    chat_ids: Vec<i64>,
438}
439
440impl RObject for UserPrivacySettingRuleRestrictChatMembers {
441    #[doc(hidden)]
442    fn extra(&self) -> Option<&str> {
443        self.extra.as_deref()
444    }
445    #[doc(hidden)]
446    fn client_id(&self) -> Option<i32> {
447        self.client_id
448    }
449}
450
451impl TDUserPrivacySettingRule for UserPrivacySettingRuleRestrictChatMembers {}
452
453impl UserPrivacySettingRuleRestrictChatMembers {
454    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
455        Ok(serde_json::from_str(json.as_ref())?)
456    }
457    pub fn builder() -> UserPrivacySettingRuleRestrictChatMembersBuilder {
458        let mut inner = UserPrivacySettingRuleRestrictChatMembers::default();
459        inner.extra = Some(Uuid::new_v4().to_string());
460
461        UserPrivacySettingRuleRestrictChatMembersBuilder { inner }
462    }
463
464    pub fn chat_ids(&self) -> &Vec<i64> {
465        &self.chat_ids
466    }
467}
468
469#[doc(hidden)]
470pub struct UserPrivacySettingRuleRestrictChatMembersBuilder {
471    inner: UserPrivacySettingRuleRestrictChatMembers,
472}
473
474#[deprecated]
475pub type RTDUserPrivacySettingRuleRestrictChatMembersBuilder =
476    UserPrivacySettingRuleRestrictChatMembersBuilder;
477
478impl UserPrivacySettingRuleRestrictChatMembersBuilder {
479    pub fn build(&self) -> UserPrivacySettingRuleRestrictChatMembers {
480        self.inner.clone()
481    }
482
483    pub fn chat_ids(&mut self, chat_ids: Vec<i64>) -> &mut Self {
484        self.inner.chat_ids = chat_ids;
485        self
486    }
487}
488
489impl AsRef<UserPrivacySettingRuleRestrictChatMembers>
490    for UserPrivacySettingRuleRestrictChatMembers
491{
492    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictChatMembers {
493        self
494    }
495}
496
497impl AsRef<UserPrivacySettingRuleRestrictChatMembers>
498    for UserPrivacySettingRuleRestrictChatMembersBuilder
499{
500    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictChatMembers {
501        &self.inner
502    }
503}
504
505/// A rule to restrict all contacts of a user from doing something
506#[derive(Debug, Clone, Default, Serialize, Deserialize)]
507pub struct UserPrivacySettingRuleRestrictContacts {
508    #[doc(hidden)]
509    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
510    extra: Option<String>,
511    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
512    client_id: Option<i32>,
513}
514
515impl RObject for UserPrivacySettingRuleRestrictContacts {
516    #[doc(hidden)]
517    fn extra(&self) -> Option<&str> {
518        self.extra.as_deref()
519    }
520    #[doc(hidden)]
521    fn client_id(&self) -> Option<i32> {
522        self.client_id
523    }
524}
525
526impl TDUserPrivacySettingRule for UserPrivacySettingRuleRestrictContacts {}
527
528impl UserPrivacySettingRuleRestrictContacts {
529    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
530        Ok(serde_json::from_str(json.as_ref())?)
531    }
532    pub fn builder() -> UserPrivacySettingRuleRestrictContactsBuilder {
533        let mut inner = UserPrivacySettingRuleRestrictContacts::default();
534        inner.extra = Some(Uuid::new_v4().to_string());
535
536        UserPrivacySettingRuleRestrictContactsBuilder { inner }
537    }
538}
539
540#[doc(hidden)]
541pub struct UserPrivacySettingRuleRestrictContactsBuilder {
542    inner: UserPrivacySettingRuleRestrictContacts,
543}
544
545#[deprecated]
546pub type RTDUserPrivacySettingRuleRestrictContactsBuilder =
547    UserPrivacySettingRuleRestrictContactsBuilder;
548
549impl UserPrivacySettingRuleRestrictContactsBuilder {
550    pub fn build(&self) -> UserPrivacySettingRuleRestrictContacts {
551        self.inner.clone()
552    }
553}
554
555impl AsRef<UserPrivacySettingRuleRestrictContacts> for UserPrivacySettingRuleRestrictContacts {
556    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictContacts {
557        self
558    }
559}
560
561impl AsRef<UserPrivacySettingRuleRestrictContacts>
562    for UserPrivacySettingRuleRestrictContactsBuilder
563{
564    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictContacts {
565        &self.inner
566    }
567}
568
569/// A rule to restrict all specified users from doing something
570#[derive(Debug, Clone, Default, Serialize, Deserialize)]
571pub struct UserPrivacySettingRuleRestrictUsers {
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    /// The user identifiers, total number of users in all rules must not exceed 1000
578
579    #[serde(default)]
580    user_ids: Vec<i64>,
581}
582
583impl RObject for UserPrivacySettingRuleRestrictUsers {
584    #[doc(hidden)]
585    fn extra(&self) -> Option<&str> {
586        self.extra.as_deref()
587    }
588    #[doc(hidden)]
589    fn client_id(&self) -> Option<i32> {
590        self.client_id
591    }
592}
593
594impl TDUserPrivacySettingRule for UserPrivacySettingRuleRestrictUsers {}
595
596impl UserPrivacySettingRuleRestrictUsers {
597    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
598        Ok(serde_json::from_str(json.as_ref())?)
599    }
600    pub fn builder() -> UserPrivacySettingRuleRestrictUsersBuilder {
601        let mut inner = UserPrivacySettingRuleRestrictUsers::default();
602        inner.extra = Some(Uuid::new_v4().to_string());
603
604        UserPrivacySettingRuleRestrictUsersBuilder { inner }
605    }
606
607    pub fn user_ids(&self) -> &Vec<i64> {
608        &self.user_ids
609    }
610}
611
612#[doc(hidden)]
613pub struct UserPrivacySettingRuleRestrictUsersBuilder {
614    inner: UserPrivacySettingRuleRestrictUsers,
615}
616
617#[deprecated]
618pub type RTDUserPrivacySettingRuleRestrictUsersBuilder = UserPrivacySettingRuleRestrictUsersBuilder;
619
620impl UserPrivacySettingRuleRestrictUsersBuilder {
621    pub fn build(&self) -> UserPrivacySettingRuleRestrictUsers {
622        self.inner.clone()
623    }
624
625    pub fn user_ids(&mut self, user_ids: Vec<i64>) -> &mut Self {
626        self.inner.user_ids = user_ids;
627        self
628    }
629}
630
631impl AsRef<UserPrivacySettingRuleRestrictUsers> for UserPrivacySettingRuleRestrictUsers {
632    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictUsers {
633        self
634    }
635}
636
637impl AsRef<UserPrivacySettingRuleRestrictUsers> for UserPrivacySettingRuleRestrictUsersBuilder {
638    fn as_ref(&self) -> &UserPrivacySettingRuleRestrictUsers {
639        &self.inner
640    }
641}
rust_tdlib/types/user_privacy_setting_rule.rs

rust_tdlib/types/
user_privacy_setting_rule.rs
