1
2use crate::types::*;
3use crate::errors::*;
4use uuid::Uuid;
5
6
7
8
9use std::fmt::Debug;
10use serde::de::{Deserialize, Deserializer};
11
12
13
14pub trait TDChatEventAction: Debug + RObject {}
16
17#[derive(Debug, Clone, Serialize)]
19#[serde(untagged)]
20pub enum ChatEventAction {
21 #[doc(hidden)] _Default(()),
22 ChatEventDescriptionChanged(ChatEventDescriptionChanged),
24 ChatEventHasProtectedContentToggled(ChatEventHasProtectedContentToggled),
26 ChatEventInviteLinkDeleted(ChatEventInviteLinkDeleted),
28 ChatEventInviteLinkEdited(ChatEventInviteLinkEdited),
30 ChatEventInviteLinkRevoked(ChatEventInviteLinkRevoked),
32 ChatEventInvitesToggled(ChatEventInvitesToggled),
34 ChatEventIsAllHistoryAvailableToggled(ChatEventIsAllHistoryAvailableToggled),
36 ChatEventLinkedChatChanged(ChatEventLinkedChatChanged),
38 ChatEventLocationChanged(ChatEventLocationChanged),
40 ChatEventMemberInvited(ChatEventMemberInvited),
42 ChatEventMemberJoined(ChatEventMemberJoined),
44 ChatEventMemberJoinedByInviteLink(ChatEventMemberJoinedByInviteLink),
46 ChatEventMemberJoinedByRequest(ChatEventMemberJoinedByRequest),
48 ChatEventMemberLeft(ChatEventMemberLeft),
50 ChatEventMemberPromoted(ChatEventMemberPromoted),
52 ChatEventMemberRestricted(ChatEventMemberRestricted),
54 ChatEventMessageDeleted(ChatEventMessageDeleted),
56 ChatEventMessageEdited(ChatEventMessageEdited),
58 ChatEventMessagePinned(ChatEventMessagePinned),
60 ChatEventMessageTtlChanged(ChatEventMessageTtlChanged),
62 ChatEventMessageUnpinned(ChatEventMessageUnpinned),
64 ChatEventPermissionsChanged(ChatEventPermissionsChanged),
66 ChatEventPhotoChanged(ChatEventPhotoChanged),
68 ChatEventPollStopped(ChatEventPollStopped),
70 ChatEventSignMessagesToggled(ChatEventSignMessagesToggled),
72 ChatEventSlowModeDelayChanged(ChatEventSlowModeDelayChanged),
74 ChatEventStickerSetChanged(ChatEventStickerSetChanged),
76 ChatEventTitleChanged(ChatEventTitleChanged),
78 ChatEventUsernameChanged(ChatEventUsernameChanged),
80 ChatEventVideoChatCreated(ChatEventVideoChatCreated),
82 ChatEventVideoChatEnded(ChatEventVideoChatEnded),
84 ChatEventVideoChatMuteNewParticipantsToggled(ChatEventVideoChatMuteNewParticipantsToggled),
86 ChatEventVideoChatParticipantIsMutedToggled(ChatEventVideoChatParticipantIsMutedToggled),
88 ChatEventVideoChatParticipantVolumeLevelChanged(ChatEventVideoChatParticipantVolumeLevelChanged),
90
91}
92
93impl Default for ChatEventAction {
94 fn default() -> Self { ChatEventAction::_Default(()) }
95}
96
97impl<'de> Deserialize<'de> for ChatEventAction {
98 fn deserialize<D>(deserializer: D) -> Result<ChatEventAction, D::Error> where D: Deserializer<'de> {
99 use serde::de::Error;
100 rtd_enum_deserialize!(
101 ChatEventAction,
102 (chatEventDescriptionChanged, ChatEventDescriptionChanged);
103 (chatEventHasProtectedContentToggled, ChatEventHasProtectedContentToggled);
104 (chatEventInviteLinkDeleted, ChatEventInviteLinkDeleted);
105 (chatEventInviteLinkEdited, ChatEventInviteLinkEdited);
106 (chatEventInviteLinkRevoked, ChatEventInviteLinkRevoked);
107 (chatEventInvitesToggled, ChatEventInvitesToggled);
108 (chatEventIsAllHistoryAvailableToggled, ChatEventIsAllHistoryAvailableToggled);
109 (chatEventLinkedChatChanged, ChatEventLinkedChatChanged);
110 (chatEventLocationChanged, ChatEventLocationChanged);
111 (chatEventMemberInvited, ChatEventMemberInvited);
112 (chatEventMemberJoined, ChatEventMemberJoined);
113 (chatEventMemberJoinedByInviteLink, ChatEventMemberJoinedByInviteLink);
114 (chatEventMemberJoinedByRequest, ChatEventMemberJoinedByRequest);
115 (chatEventMemberLeft, ChatEventMemberLeft);
116 (chatEventMemberPromoted, ChatEventMemberPromoted);
117 (chatEventMemberRestricted, ChatEventMemberRestricted);
118 (chatEventMessageDeleted, ChatEventMessageDeleted);
119 (chatEventMessageEdited, ChatEventMessageEdited);
120 (chatEventMessagePinned, ChatEventMessagePinned);
121 (chatEventMessageTtlChanged, ChatEventMessageTtlChanged);
122 (chatEventMessageUnpinned, ChatEventMessageUnpinned);
123 (chatEventPermissionsChanged, ChatEventPermissionsChanged);
124 (chatEventPhotoChanged, ChatEventPhotoChanged);
125 (chatEventPollStopped, ChatEventPollStopped);
126 (chatEventSignMessagesToggled, ChatEventSignMessagesToggled);
127 (chatEventSlowModeDelayChanged, ChatEventSlowModeDelayChanged);
128 (chatEventStickerSetChanged, ChatEventStickerSetChanged);
129 (chatEventTitleChanged, ChatEventTitleChanged);
130 (chatEventUsernameChanged, ChatEventUsernameChanged);
131 (chatEventVideoChatCreated, ChatEventVideoChatCreated);
132 (chatEventVideoChatEnded, ChatEventVideoChatEnded);
133 (chatEventVideoChatMuteNewParticipantsToggled, ChatEventVideoChatMuteNewParticipantsToggled);
134 (chatEventVideoChatParticipantIsMutedToggled, ChatEventVideoChatParticipantIsMutedToggled);
135 (chatEventVideoChatParticipantVolumeLevelChanged, ChatEventVideoChatParticipantVolumeLevelChanged);
136
137 )(deserializer)
138 }
139}
140
141impl RObject for ChatEventAction {
142 #[doc(hidden)] fn td_name(&self) -> &'static str {
143 match self {
144 ChatEventAction::ChatEventDescriptionChanged(t) => t.td_name(),
145 ChatEventAction::ChatEventHasProtectedContentToggled(t) => t.td_name(),
146 ChatEventAction::ChatEventInviteLinkDeleted(t) => t.td_name(),
147 ChatEventAction::ChatEventInviteLinkEdited(t) => t.td_name(),
148 ChatEventAction::ChatEventInviteLinkRevoked(t) => t.td_name(),
149 ChatEventAction::ChatEventInvitesToggled(t) => t.td_name(),
150 ChatEventAction::ChatEventIsAllHistoryAvailableToggled(t) => t.td_name(),
151 ChatEventAction::ChatEventLinkedChatChanged(t) => t.td_name(),
152 ChatEventAction::ChatEventLocationChanged(t) => t.td_name(),
153 ChatEventAction::ChatEventMemberInvited(t) => t.td_name(),
154 ChatEventAction::ChatEventMemberJoined(t) => t.td_name(),
155 ChatEventAction::ChatEventMemberJoinedByInviteLink(t) => t.td_name(),
156 ChatEventAction::ChatEventMemberJoinedByRequest(t) => t.td_name(),
157 ChatEventAction::ChatEventMemberLeft(t) => t.td_name(),
158 ChatEventAction::ChatEventMemberPromoted(t) => t.td_name(),
159 ChatEventAction::ChatEventMemberRestricted(t) => t.td_name(),
160 ChatEventAction::ChatEventMessageDeleted(t) => t.td_name(),
161 ChatEventAction::ChatEventMessageEdited(t) => t.td_name(),
162 ChatEventAction::ChatEventMessagePinned(t) => t.td_name(),
163 ChatEventAction::ChatEventMessageTtlChanged(t) => t.td_name(),
164 ChatEventAction::ChatEventMessageUnpinned(t) => t.td_name(),
165 ChatEventAction::ChatEventPermissionsChanged(t) => t.td_name(),
166 ChatEventAction::ChatEventPhotoChanged(t) => t.td_name(),
167 ChatEventAction::ChatEventPollStopped(t) => t.td_name(),
168 ChatEventAction::ChatEventSignMessagesToggled(t) => t.td_name(),
169 ChatEventAction::ChatEventSlowModeDelayChanged(t) => t.td_name(),
170 ChatEventAction::ChatEventStickerSetChanged(t) => t.td_name(),
171 ChatEventAction::ChatEventTitleChanged(t) => t.td_name(),
172 ChatEventAction::ChatEventUsernameChanged(t) => t.td_name(),
173 ChatEventAction::ChatEventVideoChatCreated(t) => t.td_name(),
174 ChatEventAction::ChatEventVideoChatEnded(t) => t.td_name(),
175 ChatEventAction::ChatEventVideoChatMuteNewParticipantsToggled(t) => t.td_name(),
176 ChatEventAction::ChatEventVideoChatParticipantIsMutedToggled(t) => t.td_name(),
177 ChatEventAction::ChatEventVideoChatParticipantVolumeLevelChanged(t) => t.td_name(),
178
179 _ => "-1",
180 }
181 }
182 #[doc(hidden)] fn extra(&self) -> Option<String> {
183 match self {
184 ChatEventAction::ChatEventDescriptionChanged(t) => t.extra(),
185 ChatEventAction::ChatEventHasProtectedContentToggled(t) => t.extra(),
186 ChatEventAction::ChatEventInviteLinkDeleted(t) => t.extra(),
187 ChatEventAction::ChatEventInviteLinkEdited(t) => t.extra(),
188 ChatEventAction::ChatEventInviteLinkRevoked(t) => t.extra(),
189 ChatEventAction::ChatEventInvitesToggled(t) => t.extra(),
190 ChatEventAction::ChatEventIsAllHistoryAvailableToggled(t) => t.extra(),
191 ChatEventAction::ChatEventLinkedChatChanged(t) => t.extra(),
192 ChatEventAction::ChatEventLocationChanged(t) => t.extra(),
193 ChatEventAction::ChatEventMemberInvited(t) => t.extra(),
194 ChatEventAction::ChatEventMemberJoined(t) => t.extra(),
195 ChatEventAction::ChatEventMemberJoinedByInviteLink(t) => t.extra(),
196 ChatEventAction::ChatEventMemberJoinedByRequest(t) => t.extra(),
197 ChatEventAction::ChatEventMemberLeft(t) => t.extra(),
198 ChatEventAction::ChatEventMemberPromoted(t) => t.extra(),
199 ChatEventAction::ChatEventMemberRestricted(t) => t.extra(),
200 ChatEventAction::ChatEventMessageDeleted(t) => t.extra(),
201 ChatEventAction::ChatEventMessageEdited(t) => t.extra(),
202 ChatEventAction::ChatEventMessagePinned(t) => t.extra(),
203 ChatEventAction::ChatEventMessageTtlChanged(t) => t.extra(),
204 ChatEventAction::ChatEventMessageUnpinned(t) => t.extra(),
205 ChatEventAction::ChatEventPermissionsChanged(t) => t.extra(),
206 ChatEventAction::ChatEventPhotoChanged(t) => t.extra(),
207 ChatEventAction::ChatEventPollStopped(t) => t.extra(),
208 ChatEventAction::ChatEventSignMessagesToggled(t) => t.extra(),
209 ChatEventAction::ChatEventSlowModeDelayChanged(t) => t.extra(),
210 ChatEventAction::ChatEventStickerSetChanged(t) => t.extra(),
211 ChatEventAction::ChatEventTitleChanged(t) => t.extra(),
212 ChatEventAction::ChatEventUsernameChanged(t) => t.extra(),
213 ChatEventAction::ChatEventVideoChatCreated(t) => t.extra(),
214 ChatEventAction::ChatEventVideoChatEnded(t) => t.extra(),
215 ChatEventAction::ChatEventVideoChatMuteNewParticipantsToggled(t) => t.extra(),
216 ChatEventAction::ChatEventVideoChatParticipantIsMutedToggled(t) => t.extra(),
217 ChatEventAction::ChatEventVideoChatParticipantVolumeLevelChanged(t) => t.extra(),
218
219 _ => None,
220 }
221 }
222 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
223}
224
225impl ChatEventAction {
226 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
227 #[doc(hidden)] pub fn _is_default(&self) -> bool { if let ChatEventAction::_Default(_) = self { true } else { false } }
228
229 pub fn is_chat_event_description_changed(&self) -> bool { if let ChatEventAction::ChatEventDescriptionChanged(_) = self { true } else { false } }
230 pub fn is_chat_event_has_protected_content_toggled(&self) -> bool { if let ChatEventAction::ChatEventHasProtectedContentToggled(_) = self { true } else { false } }
231 pub fn is_chat_event_invite_link_deleted(&self) -> bool { if let ChatEventAction::ChatEventInviteLinkDeleted(_) = self { true } else { false } }
232 pub fn is_chat_event_invite_link_edited(&self) -> bool { if let ChatEventAction::ChatEventInviteLinkEdited(_) = self { true } else { false } }
233 pub fn is_chat_event_invite_link_revoked(&self) -> bool { if let ChatEventAction::ChatEventInviteLinkRevoked(_) = self { true } else { false } }
234 pub fn is_chat_event_invites_toggled(&self) -> bool { if let ChatEventAction::ChatEventInvitesToggled(_) = self { true } else { false } }
235 pub fn is_chat_event_is_all_history_available_toggled(&self) -> bool { if let ChatEventAction::ChatEventIsAllHistoryAvailableToggled(_) = self { true } else { false } }
236 pub fn is_chat_event_linked_chat_changed(&self) -> bool { if let ChatEventAction::ChatEventLinkedChatChanged(_) = self { true } else { false } }
237 pub fn is_chat_event_location_changed(&self) -> bool { if let ChatEventAction::ChatEventLocationChanged(_) = self { true } else { false } }
238 pub fn is_chat_event_member_invited(&self) -> bool { if let ChatEventAction::ChatEventMemberInvited(_) = self { true } else { false } }
239 pub fn is_chat_event_member_joined(&self) -> bool { if let ChatEventAction::ChatEventMemberJoined(_) = self { true } else { false } }
240 pub fn is_chat_event_member_joined_by_invite_link(&self) -> bool { if let ChatEventAction::ChatEventMemberJoinedByInviteLink(_) = self { true } else { false } }
241 pub fn is_chat_event_member_joined_by_request(&self) -> bool { if let ChatEventAction::ChatEventMemberJoinedByRequest(_) = self { true } else { false } }
242 pub fn is_chat_event_member_left(&self) -> bool { if let ChatEventAction::ChatEventMemberLeft(_) = self { true } else { false } }
243 pub fn is_chat_event_member_promoted(&self) -> bool { if let ChatEventAction::ChatEventMemberPromoted(_) = self { true } else { false } }
244 pub fn is_chat_event_member_restricted(&self) -> bool { if let ChatEventAction::ChatEventMemberRestricted(_) = self { true } else { false } }
245 pub fn is_chat_event_message_deleted(&self) -> bool { if let ChatEventAction::ChatEventMessageDeleted(_) = self { true } else { false } }
246 pub fn is_chat_event_message_edited(&self) -> bool { if let ChatEventAction::ChatEventMessageEdited(_) = self { true } else { false } }
247 pub fn is_chat_event_message_pinned(&self) -> bool { if let ChatEventAction::ChatEventMessagePinned(_) = self { true } else { false } }
248 pub fn is_chat_event_message_ttl_changed(&self) -> bool { if let ChatEventAction::ChatEventMessageTtlChanged(_) = self { true } else { false } }
249 pub fn is_chat_event_message_unpinned(&self) -> bool { if let ChatEventAction::ChatEventMessageUnpinned(_) = self { true } else { false } }
250 pub fn is_chat_event_permissions_changed(&self) -> bool { if let ChatEventAction::ChatEventPermissionsChanged(_) = self { true } else { false } }
251 pub fn is_chat_event_photo_changed(&self) -> bool { if let ChatEventAction::ChatEventPhotoChanged(_) = self { true } else { false } }
252 pub fn is_chat_event_poll_stopped(&self) -> bool { if let ChatEventAction::ChatEventPollStopped(_) = self { true } else { false } }
253 pub fn is_chat_event_sign_messages_toggled(&self) -> bool { if let ChatEventAction::ChatEventSignMessagesToggled(_) = self { true } else { false } }
254 pub fn is_chat_event_slow_mode_delay_changed(&self) -> bool { if let ChatEventAction::ChatEventSlowModeDelayChanged(_) = self { true } else { false } }
255 pub fn is_chat_event_sticker_set_changed(&self) -> bool { if let ChatEventAction::ChatEventStickerSetChanged(_) = self { true } else { false } }
256 pub fn is_chat_event_title_changed(&self) -> bool { if let ChatEventAction::ChatEventTitleChanged(_) = self { true } else { false } }
257 pub fn is_chat_event_username_changed(&self) -> bool { if let ChatEventAction::ChatEventUsernameChanged(_) = self { true } else { false } }
258 pub fn is_chat_event_video_chat_created(&self) -> bool { if let ChatEventAction::ChatEventVideoChatCreated(_) = self { true } else { false } }
259 pub fn is_chat_event_video_chat_ended(&self) -> bool { if let ChatEventAction::ChatEventVideoChatEnded(_) = self { true } else { false } }
260 pub fn is_chat_event_video_chat_mute_new_participants_toggled(&self) -> bool { if let ChatEventAction::ChatEventVideoChatMuteNewParticipantsToggled(_) = self { true } else { false } }
261 pub fn is_chat_event_video_chat_participant_is_muted_toggled(&self) -> bool { if let ChatEventAction::ChatEventVideoChatParticipantIsMutedToggled(_) = self { true } else { false } }
262 pub fn is_chat_event_video_chat_participant_volume_level_changed(&self) -> bool { if let ChatEventAction::ChatEventVideoChatParticipantVolumeLevelChanged(_) = self { true } else { false } }
263
264 pub fn on_chat_event_description_changed<F: FnOnce(&ChatEventDescriptionChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventDescriptionChanged(t) = self { fnc(t) }; self }
265 pub fn on_chat_event_has_protected_content_toggled<F: FnOnce(&ChatEventHasProtectedContentToggled)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventHasProtectedContentToggled(t) = self { fnc(t) }; self }
266 pub fn on_chat_event_invite_link_deleted<F: FnOnce(&ChatEventInviteLinkDeleted)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventInviteLinkDeleted(t) = self { fnc(t) }; self }
267 pub fn on_chat_event_invite_link_edited<F: FnOnce(&ChatEventInviteLinkEdited)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventInviteLinkEdited(t) = self { fnc(t) }; self }
268 pub fn on_chat_event_invite_link_revoked<F: FnOnce(&ChatEventInviteLinkRevoked)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventInviteLinkRevoked(t) = self { fnc(t) }; self }
269 pub fn on_chat_event_invites_toggled<F: FnOnce(&ChatEventInvitesToggled)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventInvitesToggled(t) = self { fnc(t) }; self }
270 pub fn on_chat_event_is_all_history_available_toggled<F: FnOnce(&ChatEventIsAllHistoryAvailableToggled)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventIsAllHistoryAvailableToggled(t) = self { fnc(t) }; self }
271 pub fn on_chat_event_linked_chat_changed<F: FnOnce(&ChatEventLinkedChatChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventLinkedChatChanged(t) = self { fnc(t) }; self }
272 pub fn on_chat_event_location_changed<F: FnOnce(&ChatEventLocationChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventLocationChanged(t) = self { fnc(t) }; self }
273 pub fn on_chat_event_member_invited<F: FnOnce(&ChatEventMemberInvited)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMemberInvited(t) = self { fnc(t) }; self }
274 pub fn on_chat_event_member_joined<F: FnOnce(&ChatEventMemberJoined)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMemberJoined(t) = self { fnc(t) }; self }
275 pub fn on_chat_event_member_joined_by_invite_link<F: FnOnce(&ChatEventMemberJoinedByInviteLink)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMemberJoinedByInviteLink(t) = self { fnc(t) }; self }
276 pub fn on_chat_event_member_joined_by_request<F: FnOnce(&ChatEventMemberJoinedByRequest)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMemberJoinedByRequest(t) = self { fnc(t) }; self }
277 pub fn on_chat_event_member_left<F: FnOnce(&ChatEventMemberLeft)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMemberLeft(t) = self { fnc(t) }; self }
278 pub fn on_chat_event_member_promoted<F: FnOnce(&ChatEventMemberPromoted)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMemberPromoted(t) = self { fnc(t) }; self }
279 pub fn on_chat_event_member_restricted<F: FnOnce(&ChatEventMemberRestricted)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMemberRestricted(t) = self { fnc(t) }; self }
280 pub fn on_chat_event_message_deleted<F: FnOnce(&ChatEventMessageDeleted)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMessageDeleted(t) = self { fnc(t) }; self }
281 pub fn on_chat_event_message_edited<F: FnOnce(&ChatEventMessageEdited)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMessageEdited(t) = self { fnc(t) }; self }
282 pub fn on_chat_event_message_pinned<F: FnOnce(&ChatEventMessagePinned)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMessagePinned(t) = self { fnc(t) }; self }
283 pub fn on_chat_event_message_ttl_changed<F: FnOnce(&ChatEventMessageTtlChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMessageTtlChanged(t) = self { fnc(t) }; self }
284 pub fn on_chat_event_message_unpinned<F: FnOnce(&ChatEventMessageUnpinned)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventMessageUnpinned(t) = self { fnc(t) }; self }
285 pub fn on_chat_event_permissions_changed<F: FnOnce(&ChatEventPermissionsChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventPermissionsChanged(t) = self { fnc(t) }; self }
286 pub fn on_chat_event_photo_changed<F: FnOnce(&ChatEventPhotoChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventPhotoChanged(t) = self { fnc(t) }; self }
287 pub fn on_chat_event_poll_stopped<F: FnOnce(&ChatEventPollStopped)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventPollStopped(t) = self { fnc(t) }; self }
288 pub fn on_chat_event_sign_messages_toggled<F: FnOnce(&ChatEventSignMessagesToggled)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventSignMessagesToggled(t) = self { fnc(t) }; self }
289 pub fn on_chat_event_slow_mode_delay_changed<F: FnOnce(&ChatEventSlowModeDelayChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventSlowModeDelayChanged(t) = self { fnc(t) }; self }
290 pub fn on_chat_event_sticker_set_changed<F: FnOnce(&ChatEventStickerSetChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventStickerSetChanged(t) = self { fnc(t) }; self }
291 pub fn on_chat_event_title_changed<F: FnOnce(&ChatEventTitleChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventTitleChanged(t) = self { fnc(t) }; self }
292 pub fn on_chat_event_username_changed<F: FnOnce(&ChatEventUsernameChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventUsernameChanged(t) = self { fnc(t) }; self }
293 pub fn on_chat_event_video_chat_created<F: FnOnce(&ChatEventVideoChatCreated)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventVideoChatCreated(t) = self { fnc(t) }; self }
294 pub fn on_chat_event_video_chat_ended<F: FnOnce(&ChatEventVideoChatEnded)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventVideoChatEnded(t) = self { fnc(t) }; self }
295 pub fn on_chat_event_video_chat_mute_new_participants_toggled<F: FnOnce(&ChatEventVideoChatMuteNewParticipantsToggled)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventVideoChatMuteNewParticipantsToggled(t) = self { fnc(t) }; self }
296 pub fn on_chat_event_video_chat_participant_is_muted_toggled<F: FnOnce(&ChatEventVideoChatParticipantIsMutedToggled)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventVideoChatParticipantIsMutedToggled(t) = self { fnc(t) }; self }
297 pub fn on_chat_event_video_chat_participant_volume_level_changed<F: FnOnce(&ChatEventVideoChatParticipantVolumeLevelChanged)>(&self, fnc: F) -> &Self { if let ChatEventAction::ChatEventVideoChatParticipantVolumeLevelChanged(t) = self { fnc(t) }; self }
298
299 pub fn as_chat_event_description_changed(&self) -> Option<&ChatEventDescriptionChanged> { if let ChatEventAction::ChatEventDescriptionChanged(t) = self { return Some(t) } None }
300 pub fn as_chat_event_has_protected_content_toggled(&self) -> Option<&ChatEventHasProtectedContentToggled> { if let ChatEventAction::ChatEventHasProtectedContentToggled(t) = self { return Some(t) } None }
301 pub fn as_chat_event_invite_link_deleted(&self) -> Option<&ChatEventInviteLinkDeleted> { if let ChatEventAction::ChatEventInviteLinkDeleted(t) = self { return Some(t) } None }
302 pub fn as_chat_event_invite_link_edited(&self) -> Option<&ChatEventInviteLinkEdited> { if let ChatEventAction::ChatEventInviteLinkEdited(t) = self { return Some(t) } None }
303 pub fn as_chat_event_invite_link_revoked(&self) -> Option<&ChatEventInviteLinkRevoked> { if let ChatEventAction::ChatEventInviteLinkRevoked(t) = self { return Some(t) } None }
304 pub fn as_chat_event_invites_toggled(&self) -> Option<&ChatEventInvitesToggled> { if let ChatEventAction::ChatEventInvitesToggled(t) = self { return Some(t) } None }
305 pub fn as_chat_event_is_all_history_available_toggled(&self) -> Option<&ChatEventIsAllHistoryAvailableToggled> { if let ChatEventAction::ChatEventIsAllHistoryAvailableToggled(t) = self { return Some(t) } None }
306 pub fn as_chat_event_linked_chat_changed(&self) -> Option<&ChatEventLinkedChatChanged> { if let ChatEventAction::ChatEventLinkedChatChanged(t) = self { return Some(t) } None }
307 pub fn as_chat_event_location_changed(&self) -> Option<&ChatEventLocationChanged> { if let ChatEventAction::ChatEventLocationChanged(t) = self { return Some(t) } None }
308 pub fn as_chat_event_member_invited(&self) -> Option<&ChatEventMemberInvited> { if let ChatEventAction::ChatEventMemberInvited(t) = self { return Some(t) } None }
309 pub fn as_chat_event_member_joined(&self) -> Option<&ChatEventMemberJoined> { if let ChatEventAction::ChatEventMemberJoined(t) = self { return Some(t) } None }
310 pub fn as_chat_event_member_joined_by_invite_link(&self) -> Option<&ChatEventMemberJoinedByInviteLink> { if let ChatEventAction::ChatEventMemberJoinedByInviteLink(t) = self { return Some(t) } None }
311 pub fn as_chat_event_member_joined_by_request(&self) -> Option<&ChatEventMemberJoinedByRequest> { if let ChatEventAction::ChatEventMemberJoinedByRequest(t) = self { return Some(t) } None }
312 pub fn as_chat_event_member_left(&self) -> Option<&ChatEventMemberLeft> { if let ChatEventAction::ChatEventMemberLeft(t) = self { return Some(t) } None }
313 pub fn as_chat_event_member_promoted(&self) -> Option<&ChatEventMemberPromoted> { if let ChatEventAction::ChatEventMemberPromoted(t) = self { return Some(t) } None }
314 pub fn as_chat_event_member_restricted(&self) -> Option<&ChatEventMemberRestricted> { if let ChatEventAction::ChatEventMemberRestricted(t) = self { return Some(t) } None }
315 pub fn as_chat_event_message_deleted(&self) -> Option<&ChatEventMessageDeleted> { if let ChatEventAction::ChatEventMessageDeleted(t) = self { return Some(t) } None }
316 pub fn as_chat_event_message_edited(&self) -> Option<&ChatEventMessageEdited> { if let ChatEventAction::ChatEventMessageEdited(t) = self { return Some(t) } None }
317 pub fn as_chat_event_message_pinned(&self) -> Option<&ChatEventMessagePinned> { if let ChatEventAction::ChatEventMessagePinned(t) = self { return Some(t) } None }
318 pub fn as_chat_event_message_ttl_changed(&self) -> Option<&ChatEventMessageTtlChanged> { if let ChatEventAction::ChatEventMessageTtlChanged(t) = self { return Some(t) } None }
319 pub fn as_chat_event_message_unpinned(&self) -> Option<&ChatEventMessageUnpinned> { if let ChatEventAction::ChatEventMessageUnpinned(t) = self { return Some(t) } None }
320 pub fn as_chat_event_permissions_changed(&self) -> Option<&ChatEventPermissionsChanged> { if let ChatEventAction::ChatEventPermissionsChanged(t) = self { return Some(t) } None }
321 pub fn as_chat_event_photo_changed(&self) -> Option<&ChatEventPhotoChanged> { if let ChatEventAction::ChatEventPhotoChanged(t) = self { return Some(t) } None }
322 pub fn as_chat_event_poll_stopped(&self) -> Option<&ChatEventPollStopped> { if let ChatEventAction::ChatEventPollStopped(t) = self { return Some(t) } None }
323 pub fn as_chat_event_sign_messages_toggled(&self) -> Option<&ChatEventSignMessagesToggled> { if let ChatEventAction::ChatEventSignMessagesToggled(t) = self { return Some(t) } None }
324 pub fn as_chat_event_slow_mode_delay_changed(&self) -> Option<&ChatEventSlowModeDelayChanged> { if let ChatEventAction::ChatEventSlowModeDelayChanged(t) = self { return Some(t) } None }
325 pub fn as_chat_event_sticker_set_changed(&self) -> Option<&ChatEventStickerSetChanged> { if let ChatEventAction::ChatEventStickerSetChanged(t) = self { return Some(t) } None }
326 pub fn as_chat_event_title_changed(&self) -> Option<&ChatEventTitleChanged> { if let ChatEventAction::ChatEventTitleChanged(t) = self { return Some(t) } None }
327 pub fn as_chat_event_username_changed(&self) -> Option<&ChatEventUsernameChanged> { if let ChatEventAction::ChatEventUsernameChanged(t) = self { return Some(t) } None }
328 pub fn as_chat_event_video_chat_created(&self) -> Option<&ChatEventVideoChatCreated> { if let ChatEventAction::ChatEventVideoChatCreated(t) = self { return Some(t) } None }
329 pub fn as_chat_event_video_chat_ended(&self) -> Option<&ChatEventVideoChatEnded> { if let ChatEventAction::ChatEventVideoChatEnded(t) = self { return Some(t) } None }
330 pub fn as_chat_event_video_chat_mute_new_participants_toggled(&self) -> Option<&ChatEventVideoChatMuteNewParticipantsToggled> { if let ChatEventAction::ChatEventVideoChatMuteNewParticipantsToggled(t) = self { return Some(t) } None }
331 pub fn as_chat_event_video_chat_participant_is_muted_toggled(&self) -> Option<&ChatEventVideoChatParticipantIsMutedToggled> { if let ChatEventAction::ChatEventVideoChatParticipantIsMutedToggled(t) = self { return Some(t) } None }
332 pub fn as_chat_event_video_chat_participant_volume_level_changed(&self) -> Option<&ChatEventVideoChatParticipantVolumeLevelChanged> { if let ChatEventAction::ChatEventVideoChatParticipantVolumeLevelChanged(t) = self { return Some(t) } None }
333
334
335
336 pub fn chat_event_description_changed<T: AsRef<ChatEventDescriptionChanged>>(t: T) -> Self { ChatEventAction::ChatEventDescriptionChanged(t.as_ref().clone()) }
337
338 pub fn chat_event_has_protected_content_toggled<T: AsRef<ChatEventHasProtectedContentToggled>>(t: T) -> Self { ChatEventAction::ChatEventHasProtectedContentToggled(t.as_ref().clone()) }
339
340 pub fn chat_event_invite_link_deleted<T: AsRef<ChatEventInviteLinkDeleted>>(t: T) -> Self { ChatEventAction::ChatEventInviteLinkDeleted(t.as_ref().clone()) }
341
342 pub fn chat_event_invite_link_edited<T: AsRef<ChatEventInviteLinkEdited>>(t: T) -> Self { ChatEventAction::ChatEventInviteLinkEdited(t.as_ref().clone()) }
343
344 pub fn chat_event_invite_link_revoked<T: AsRef<ChatEventInviteLinkRevoked>>(t: T) -> Self { ChatEventAction::ChatEventInviteLinkRevoked(t.as_ref().clone()) }
345
346 pub fn chat_event_invites_toggled<T: AsRef<ChatEventInvitesToggled>>(t: T) -> Self { ChatEventAction::ChatEventInvitesToggled(t.as_ref().clone()) }
347
348 pub fn chat_event_is_all_history_available_toggled<T: AsRef<ChatEventIsAllHistoryAvailableToggled>>(t: T) -> Self { ChatEventAction::ChatEventIsAllHistoryAvailableToggled(t.as_ref().clone()) }
349
350 pub fn chat_event_linked_chat_changed<T: AsRef<ChatEventLinkedChatChanged>>(t: T) -> Self { ChatEventAction::ChatEventLinkedChatChanged(t.as_ref().clone()) }
351
352 pub fn chat_event_location_changed<T: AsRef<ChatEventLocationChanged>>(t: T) -> Self { ChatEventAction::ChatEventLocationChanged(t.as_ref().clone()) }
353
354 pub fn chat_event_member_invited<T: AsRef<ChatEventMemberInvited>>(t: T) -> Self { ChatEventAction::ChatEventMemberInvited(t.as_ref().clone()) }
355
356 pub fn chat_event_member_joined<T: AsRef<ChatEventMemberJoined>>(t: T) -> Self { ChatEventAction::ChatEventMemberJoined(t.as_ref().clone()) }
357
358 pub fn chat_event_member_joined_by_invite_link<T: AsRef<ChatEventMemberJoinedByInviteLink>>(t: T) -> Self { ChatEventAction::ChatEventMemberJoinedByInviteLink(t.as_ref().clone()) }
359
360 pub fn chat_event_member_joined_by_request<T: AsRef<ChatEventMemberJoinedByRequest>>(t: T) -> Self { ChatEventAction::ChatEventMemberJoinedByRequest(t.as_ref().clone()) }
361
362 pub fn chat_event_member_left<T: AsRef<ChatEventMemberLeft>>(t: T) -> Self { ChatEventAction::ChatEventMemberLeft(t.as_ref().clone()) }
363
364 pub fn chat_event_member_promoted<T: AsRef<ChatEventMemberPromoted>>(t: T) -> Self { ChatEventAction::ChatEventMemberPromoted(t.as_ref().clone()) }
365
366 pub fn chat_event_member_restricted<T: AsRef<ChatEventMemberRestricted>>(t: T) -> Self { ChatEventAction::ChatEventMemberRestricted(t.as_ref().clone()) }
367
368 pub fn chat_event_message_deleted<T: AsRef<ChatEventMessageDeleted>>(t: T) -> Self { ChatEventAction::ChatEventMessageDeleted(t.as_ref().clone()) }
369
370 pub fn chat_event_message_edited<T: AsRef<ChatEventMessageEdited>>(t: T) -> Self { ChatEventAction::ChatEventMessageEdited(t.as_ref().clone()) }
371
372 pub fn chat_event_message_pinned<T: AsRef<ChatEventMessagePinned>>(t: T) -> Self { ChatEventAction::ChatEventMessagePinned(t.as_ref().clone()) }
373
374 pub fn chat_event_message_ttl_changed<T: AsRef<ChatEventMessageTtlChanged>>(t: T) -> Self { ChatEventAction::ChatEventMessageTtlChanged(t.as_ref().clone()) }
375
376 pub fn chat_event_message_unpinned<T: AsRef<ChatEventMessageUnpinned>>(t: T) -> Self { ChatEventAction::ChatEventMessageUnpinned(t.as_ref().clone()) }
377
378 pub fn chat_event_permissions_changed<T: AsRef<ChatEventPermissionsChanged>>(t: T) -> Self { ChatEventAction::ChatEventPermissionsChanged(t.as_ref().clone()) }
379
380 pub fn chat_event_photo_changed<T: AsRef<ChatEventPhotoChanged>>(t: T) -> Self { ChatEventAction::ChatEventPhotoChanged(t.as_ref().clone()) }
381
382 pub fn chat_event_poll_stopped<T: AsRef<ChatEventPollStopped>>(t: T) -> Self { ChatEventAction::ChatEventPollStopped(t.as_ref().clone()) }
383
384 pub fn chat_event_sign_messages_toggled<T: AsRef<ChatEventSignMessagesToggled>>(t: T) -> Self { ChatEventAction::ChatEventSignMessagesToggled(t.as_ref().clone()) }
385
386 pub fn chat_event_slow_mode_delay_changed<T: AsRef<ChatEventSlowModeDelayChanged>>(t: T) -> Self { ChatEventAction::ChatEventSlowModeDelayChanged(t.as_ref().clone()) }
387
388 pub fn chat_event_sticker_set_changed<T: AsRef<ChatEventStickerSetChanged>>(t: T) -> Self { ChatEventAction::ChatEventStickerSetChanged(t.as_ref().clone()) }
389
390 pub fn chat_event_title_changed<T: AsRef<ChatEventTitleChanged>>(t: T) -> Self { ChatEventAction::ChatEventTitleChanged(t.as_ref().clone()) }
391
392 pub fn chat_event_username_changed<T: AsRef<ChatEventUsernameChanged>>(t: T) -> Self { ChatEventAction::ChatEventUsernameChanged(t.as_ref().clone()) }
393
394 pub fn chat_event_video_chat_created<T: AsRef<ChatEventVideoChatCreated>>(t: T) -> Self { ChatEventAction::ChatEventVideoChatCreated(t.as_ref().clone()) }
395
396 pub fn chat_event_video_chat_ended<T: AsRef<ChatEventVideoChatEnded>>(t: T) -> Self { ChatEventAction::ChatEventVideoChatEnded(t.as_ref().clone()) }
397
398 pub fn chat_event_video_chat_mute_new_participants_toggled<T: AsRef<ChatEventVideoChatMuteNewParticipantsToggled>>(t: T) -> Self { ChatEventAction::ChatEventVideoChatMuteNewParticipantsToggled(t.as_ref().clone()) }
399
400 pub fn chat_event_video_chat_participant_is_muted_toggled<T: AsRef<ChatEventVideoChatParticipantIsMutedToggled>>(t: T) -> Self { ChatEventAction::ChatEventVideoChatParticipantIsMutedToggled(t.as_ref().clone()) }
401
402 pub fn chat_event_video_chat_participant_volume_level_changed<T: AsRef<ChatEventVideoChatParticipantVolumeLevelChanged>>(t: T) -> Self { ChatEventAction::ChatEventVideoChatParticipantVolumeLevelChanged(t.as_ref().clone()) }
403
404}
405
406impl AsRef<ChatEventAction> for ChatEventAction {
407 fn as_ref(&self) -> &ChatEventAction { self }
408}
409
410
411
412
413
414
415
416#[derive(Debug, Clone, Default, Serialize, Deserialize)]
418pub struct ChatEventDescriptionChanged {
419 #[doc(hidden)]
420 #[serde(rename(serialize = "@type", deserialize = "@type"))]
421 td_name: String,
422 #[doc(hidden)]
423 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
424 extra: Option<String>,
425 old_description: String,
427 new_description: String,
429
430}
431
432impl RObject for ChatEventDescriptionChanged {
433 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventDescriptionChanged" }
434 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
435 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
436}
437
438
439impl TDChatEventAction for ChatEventDescriptionChanged {}
440
441
442
443impl ChatEventDescriptionChanged {
444 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
445 pub fn builder() -> RTDChatEventDescriptionChangedBuilder {
446 let mut inner = ChatEventDescriptionChanged::default();
447 inner.td_name = "chatEventDescriptionChanged".to_string();
448 inner.extra = Some(Uuid::new_v4().to_string());
449 RTDChatEventDescriptionChangedBuilder { inner }
450 }
451
452 pub fn old_description(&self) -> &String { &self.old_description }
453
454 pub fn new_description(&self) -> &String { &self.new_description }
455
456}
457
458#[doc(hidden)]
459pub struct RTDChatEventDescriptionChangedBuilder {
460 inner: ChatEventDescriptionChanged
461}
462
463impl RTDChatEventDescriptionChangedBuilder {
464 pub fn build(&self) -> ChatEventDescriptionChanged { self.inner.clone() }
465
466
467 pub fn old_description<T: AsRef<str>>(&mut self, old_description: T) -> &mut Self {
468 self.inner.old_description = old_description.as_ref().to_string();
469 self
470 }
471
472
473 pub fn new_description<T: AsRef<str>>(&mut self, new_description: T) -> &mut Self {
474 self.inner.new_description = new_description.as_ref().to_string();
475 self
476 }
477
478}
479
480impl AsRef<ChatEventDescriptionChanged> for ChatEventDescriptionChanged {
481 fn as_ref(&self) -> &ChatEventDescriptionChanged { self }
482}
483
484impl AsRef<ChatEventDescriptionChanged> for RTDChatEventDescriptionChangedBuilder {
485 fn as_ref(&self) -> &ChatEventDescriptionChanged { &self.inner }
486}
487
488
489
490
491
492
493
494#[derive(Debug, Clone, Default, Serialize, Deserialize)]
496pub struct ChatEventHasProtectedContentToggled {
497 #[doc(hidden)]
498 #[serde(rename(serialize = "@type", deserialize = "@type"))]
499 td_name: String,
500 #[doc(hidden)]
501 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
502 extra: Option<String>,
503 has_protected_content: bool,
505
506}
507
508impl RObject for ChatEventHasProtectedContentToggled {
509 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventHasProtectedContentToggled" }
510 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
511 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
512}
513
514
515impl TDChatEventAction for ChatEventHasProtectedContentToggled {}
516
517
518
519impl ChatEventHasProtectedContentToggled {
520 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
521 pub fn builder() -> RTDChatEventHasProtectedContentToggledBuilder {
522 let mut inner = ChatEventHasProtectedContentToggled::default();
523 inner.td_name = "chatEventHasProtectedContentToggled".to_string();
524 inner.extra = Some(Uuid::new_v4().to_string());
525 RTDChatEventHasProtectedContentToggledBuilder { inner }
526 }
527
528 pub fn has_protected_content(&self) -> bool { self.has_protected_content }
529
530}
531
532#[doc(hidden)]
533pub struct RTDChatEventHasProtectedContentToggledBuilder {
534 inner: ChatEventHasProtectedContentToggled
535}
536
537impl RTDChatEventHasProtectedContentToggledBuilder {
538 pub fn build(&self) -> ChatEventHasProtectedContentToggled { self.inner.clone() }
539
540
541 pub fn has_protected_content(&mut self, has_protected_content: bool) -> &mut Self {
542 self.inner.has_protected_content = has_protected_content;
543 self
544 }
545
546}
547
548impl AsRef<ChatEventHasProtectedContentToggled> for ChatEventHasProtectedContentToggled {
549 fn as_ref(&self) -> &ChatEventHasProtectedContentToggled { self }
550}
551
552impl AsRef<ChatEventHasProtectedContentToggled> for RTDChatEventHasProtectedContentToggledBuilder {
553 fn as_ref(&self) -> &ChatEventHasProtectedContentToggled { &self.inner }
554}
555
556
557
558
559
560
561
562#[derive(Debug, Clone, Default, Serialize, Deserialize)]
564pub struct ChatEventInviteLinkDeleted {
565 #[doc(hidden)]
566 #[serde(rename(serialize = "@type", deserialize = "@type"))]
567 td_name: String,
568 #[doc(hidden)]
569 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
570 extra: Option<String>,
571 invite_link: ChatInviteLink,
573
574}
575
576impl RObject for ChatEventInviteLinkDeleted {
577 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventInviteLinkDeleted" }
578 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
579 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
580}
581
582
583impl TDChatEventAction for ChatEventInviteLinkDeleted {}
584
585
586
587impl ChatEventInviteLinkDeleted {
588 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
589 pub fn builder() -> RTDChatEventInviteLinkDeletedBuilder {
590 let mut inner = ChatEventInviteLinkDeleted::default();
591 inner.td_name = "chatEventInviteLinkDeleted".to_string();
592 inner.extra = Some(Uuid::new_v4().to_string());
593 RTDChatEventInviteLinkDeletedBuilder { inner }
594 }
595
596 pub fn invite_link(&self) -> &ChatInviteLink { &self.invite_link }
597
598}
599
600#[doc(hidden)]
601pub struct RTDChatEventInviteLinkDeletedBuilder {
602 inner: ChatEventInviteLinkDeleted
603}
604
605impl RTDChatEventInviteLinkDeletedBuilder {
606 pub fn build(&self) -> ChatEventInviteLinkDeleted { self.inner.clone() }
607
608
609 pub fn invite_link<T: AsRef<ChatInviteLink>>(&mut self, invite_link: T) -> &mut Self {
610 self.inner.invite_link = invite_link.as_ref().clone();
611 self
612 }
613
614}
615
616impl AsRef<ChatEventInviteLinkDeleted> for ChatEventInviteLinkDeleted {
617 fn as_ref(&self) -> &ChatEventInviteLinkDeleted { self }
618}
619
620impl AsRef<ChatEventInviteLinkDeleted> for RTDChatEventInviteLinkDeletedBuilder {
621 fn as_ref(&self) -> &ChatEventInviteLinkDeleted { &self.inner }
622}
623
624
625
626
627
628
629
630#[derive(Debug, Clone, Default, Serialize, Deserialize)]
632pub struct ChatEventInviteLinkEdited {
633 #[doc(hidden)]
634 #[serde(rename(serialize = "@type", deserialize = "@type"))]
635 td_name: String,
636 #[doc(hidden)]
637 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
638 extra: Option<String>,
639 old_invite_link: ChatInviteLink,
641 new_invite_link: ChatInviteLink,
643
644}
645
646impl RObject for ChatEventInviteLinkEdited {
647 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventInviteLinkEdited" }
648 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
649 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
650}
651
652
653impl TDChatEventAction for ChatEventInviteLinkEdited {}
654
655
656
657impl ChatEventInviteLinkEdited {
658 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
659 pub fn builder() -> RTDChatEventInviteLinkEditedBuilder {
660 let mut inner = ChatEventInviteLinkEdited::default();
661 inner.td_name = "chatEventInviteLinkEdited".to_string();
662 inner.extra = Some(Uuid::new_v4().to_string());
663 RTDChatEventInviteLinkEditedBuilder { inner }
664 }
665
666 pub fn old_invite_link(&self) -> &ChatInviteLink { &self.old_invite_link }
667
668 pub fn new_invite_link(&self) -> &ChatInviteLink { &self.new_invite_link }
669
670}
671
672#[doc(hidden)]
673pub struct RTDChatEventInviteLinkEditedBuilder {
674 inner: ChatEventInviteLinkEdited
675}
676
677impl RTDChatEventInviteLinkEditedBuilder {
678 pub fn build(&self) -> ChatEventInviteLinkEdited { self.inner.clone() }
679
680
681 pub fn old_invite_link<T: AsRef<ChatInviteLink>>(&mut self, old_invite_link: T) -> &mut Self {
682 self.inner.old_invite_link = old_invite_link.as_ref().clone();
683 self
684 }
685
686
687 pub fn new_invite_link<T: AsRef<ChatInviteLink>>(&mut self, new_invite_link: T) -> &mut Self {
688 self.inner.new_invite_link = new_invite_link.as_ref().clone();
689 self
690 }
691
692}
693
694impl AsRef<ChatEventInviteLinkEdited> for ChatEventInviteLinkEdited {
695 fn as_ref(&self) -> &ChatEventInviteLinkEdited { self }
696}
697
698impl AsRef<ChatEventInviteLinkEdited> for RTDChatEventInviteLinkEditedBuilder {
699 fn as_ref(&self) -> &ChatEventInviteLinkEdited { &self.inner }
700}
701
702
703
704
705
706
707
708#[derive(Debug, Clone, Default, Serialize, Deserialize)]
710pub struct ChatEventInviteLinkRevoked {
711 #[doc(hidden)]
712 #[serde(rename(serialize = "@type", deserialize = "@type"))]
713 td_name: String,
714 #[doc(hidden)]
715 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
716 extra: Option<String>,
717 invite_link: ChatInviteLink,
719
720}
721
722impl RObject for ChatEventInviteLinkRevoked {
723 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventInviteLinkRevoked" }
724 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
725 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
726}
727
728
729impl TDChatEventAction for ChatEventInviteLinkRevoked {}
730
731
732
733impl ChatEventInviteLinkRevoked {
734 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
735 pub fn builder() -> RTDChatEventInviteLinkRevokedBuilder {
736 let mut inner = ChatEventInviteLinkRevoked::default();
737 inner.td_name = "chatEventInviteLinkRevoked".to_string();
738 inner.extra = Some(Uuid::new_v4().to_string());
739 RTDChatEventInviteLinkRevokedBuilder { inner }
740 }
741
742 pub fn invite_link(&self) -> &ChatInviteLink { &self.invite_link }
743
744}
745
746#[doc(hidden)]
747pub struct RTDChatEventInviteLinkRevokedBuilder {
748 inner: ChatEventInviteLinkRevoked
749}
750
751impl RTDChatEventInviteLinkRevokedBuilder {
752 pub fn build(&self) -> ChatEventInviteLinkRevoked { self.inner.clone() }
753
754
755 pub fn invite_link<T: AsRef<ChatInviteLink>>(&mut self, invite_link: T) -> &mut Self {
756 self.inner.invite_link = invite_link.as_ref().clone();
757 self
758 }
759
760}
761
762impl AsRef<ChatEventInviteLinkRevoked> for ChatEventInviteLinkRevoked {
763 fn as_ref(&self) -> &ChatEventInviteLinkRevoked { self }
764}
765
766impl AsRef<ChatEventInviteLinkRevoked> for RTDChatEventInviteLinkRevokedBuilder {
767 fn as_ref(&self) -> &ChatEventInviteLinkRevoked { &self.inner }
768}
769
770
771
772
773
774
775
776#[derive(Debug, Clone, Default, Serialize, Deserialize)]
778pub struct ChatEventInvitesToggled {
779 #[doc(hidden)]
780 #[serde(rename(serialize = "@type", deserialize = "@type"))]
781 td_name: String,
782 #[doc(hidden)]
783 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
784 extra: Option<String>,
785 can_invite_users: bool,
787
788}
789
790impl RObject for ChatEventInvitesToggled {
791 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventInvitesToggled" }
792 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
793 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
794}
795
796
797impl TDChatEventAction for ChatEventInvitesToggled {}
798
799
800
801impl ChatEventInvitesToggled {
802 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
803 pub fn builder() -> RTDChatEventInvitesToggledBuilder {
804 let mut inner = ChatEventInvitesToggled::default();
805 inner.td_name = "chatEventInvitesToggled".to_string();
806 inner.extra = Some(Uuid::new_v4().to_string());
807 RTDChatEventInvitesToggledBuilder { inner }
808 }
809
810 pub fn can_invite_users(&self) -> bool { self.can_invite_users }
811
812}
813
814#[doc(hidden)]
815pub struct RTDChatEventInvitesToggledBuilder {
816 inner: ChatEventInvitesToggled
817}
818
819impl RTDChatEventInvitesToggledBuilder {
820 pub fn build(&self) -> ChatEventInvitesToggled { self.inner.clone() }
821
822
823 pub fn can_invite_users(&mut self, can_invite_users: bool) -> &mut Self {
824 self.inner.can_invite_users = can_invite_users;
825 self
826 }
827
828}
829
830impl AsRef<ChatEventInvitesToggled> for ChatEventInvitesToggled {
831 fn as_ref(&self) -> &ChatEventInvitesToggled { self }
832}
833
834impl AsRef<ChatEventInvitesToggled> for RTDChatEventInvitesToggledBuilder {
835 fn as_ref(&self) -> &ChatEventInvitesToggled { &self.inner }
836}
837
838
839
840
841
842
843
844#[derive(Debug, Clone, Default, Serialize, Deserialize)]
846pub struct ChatEventIsAllHistoryAvailableToggled {
847 #[doc(hidden)]
848 #[serde(rename(serialize = "@type", deserialize = "@type"))]
849 td_name: String,
850 #[doc(hidden)]
851 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
852 extra: Option<String>,
853 is_all_history_available: bool,
855
856}
857
858impl RObject for ChatEventIsAllHistoryAvailableToggled {
859 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventIsAllHistoryAvailableToggled" }
860 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
861 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
862}
863
864
865impl TDChatEventAction for ChatEventIsAllHistoryAvailableToggled {}
866
867
868
869impl ChatEventIsAllHistoryAvailableToggled {
870 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
871 pub fn builder() -> RTDChatEventIsAllHistoryAvailableToggledBuilder {
872 let mut inner = ChatEventIsAllHistoryAvailableToggled::default();
873 inner.td_name = "chatEventIsAllHistoryAvailableToggled".to_string();
874 inner.extra = Some(Uuid::new_v4().to_string());
875 RTDChatEventIsAllHistoryAvailableToggledBuilder { inner }
876 }
877
878 pub fn is_all_history_available(&self) -> bool { self.is_all_history_available }
879
880}
881
882#[doc(hidden)]
883pub struct RTDChatEventIsAllHistoryAvailableToggledBuilder {
884 inner: ChatEventIsAllHistoryAvailableToggled
885}
886
887impl RTDChatEventIsAllHistoryAvailableToggledBuilder {
888 pub fn build(&self) -> ChatEventIsAllHistoryAvailableToggled { self.inner.clone() }
889
890
891 pub fn is_all_history_available(&mut self, is_all_history_available: bool) -> &mut Self {
892 self.inner.is_all_history_available = is_all_history_available;
893 self
894 }
895
896}
897
898impl AsRef<ChatEventIsAllHistoryAvailableToggled> for ChatEventIsAllHistoryAvailableToggled {
899 fn as_ref(&self) -> &ChatEventIsAllHistoryAvailableToggled { self }
900}
901
902impl AsRef<ChatEventIsAllHistoryAvailableToggled> for RTDChatEventIsAllHistoryAvailableToggledBuilder {
903 fn as_ref(&self) -> &ChatEventIsAllHistoryAvailableToggled { &self.inner }
904}
905
906
907
908
909
910
911
912#[derive(Debug, Clone, Default, Serialize, Deserialize)]
914pub struct ChatEventLinkedChatChanged {
915 #[doc(hidden)]
916 #[serde(rename(serialize = "@type", deserialize = "@type"))]
917 td_name: String,
918 #[doc(hidden)]
919 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
920 extra: Option<String>,
921 old_linked_chat_id: i64,
923 new_linked_chat_id: i64,
925
926}
927
928impl RObject for ChatEventLinkedChatChanged {
929 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventLinkedChatChanged" }
930 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
931 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
932}
933
934
935impl TDChatEventAction for ChatEventLinkedChatChanged {}
936
937
938
939impl ChatEventLinkedChatChanged {
940 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
941 pub fn builder() -> RTDChatEventLinkedChatChangedBuilder {
942 let mut inner = ChatEventLinkedChatChanged::default();
943 inner.td_name = "chatEventLinkedChatChanged".to_string();
944 inner.extra = Some(Uuid::new_v4().to_string());
945 RTDChatEventLinkedChatChangedBuilder { inner }
946 }
947
948 pub fn old_linked_chat_id(&self) -> i64 { self.old_linked_chat_id }
949
950 pub fn new_linked_chat_id(&self) -> i64 { self.new_linked_chat_id }
951
952}
953
954#[doc(hidden)]
955pub struct RTDChatEventLinkedChatChangedBuilder {
956 inner: ChatEventLinkedChatChanged
957}
958
959impl RTDChatEventLinkedChatChangedBuilder {
960 pub fn build(&self) -> ChatEventLinkedChatChanged { self.inner.clone() }
961
962
963 pub fn old_linked_chat_id(&mut self, old_linked_chat_id: i64) -> &mut Self {
964 self.inner.old_linked_chat_id = old_linked_chat_id;
965 self
966 }
967
968
969 pub fn new_linked_chat_id(&mut self, new_linked_chat_id: i64) -> &mut Self {
970 self.inner.new_linked_chat_id = new_linked_chat_id;
971 self
972 }
973
974}
975
976impl AsRef<ChatEventLinkedChatChanged> for ChatEventLinkedChatChanged {
977 fn as_ref(&self) -> &ChatEventLinkedChatChanged { self }
978}
979
980impl AsRef<ChatEventLinkedChatChanged> for RTDChatEventLinkedChatChangedBuilder {
981 fn as_ref(&self) -> &ChatEventLinkedChatChanged { &self.inner }
982}
983
984
985
986
987
988
989
990#[derive(Debug, Clone, Default, Serialize, Deserialize)]
992pub struct ChatEventLocationChanged {
993 #[doc(hidden)]
994 #[serde(rename(serialize = "@type", deserialize = "@type"))]
995 td_name: String,
996 #[doc(hidden)]
997 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
998 extra: Option<String>,
999 old_location: Option<ChatLocation>,
1001 new_location: Option<ChatLocation>,
1003
1004}
1005
1006impl RObject for ChatEventLocationChanged {
1007 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventLocationChanged" }
1008 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1009 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1010}
1011
1012
1013impl TDChatEventAction for ChatEventLocationChanged {}
1014
1015
1016
1017impl ChatEventLocationChanged {
1018 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1019 pub fn builder() -> RTDChatEventLocationChangedBuilder {
1020 let mut inner = ChatEventLocationChanged::default();
1021 inner.td_name = "chatEventLocationChanged".to_string();
1022 inner.extra = Some(Uuid::new_v4().to_string());
1023 RTDChatEventLocationChangedBuilder { inner }
1024 }
1025
1026 pub fn old_location(&self) -> &Option<ChatLocation> { &self.old_location }
1027
1028 pub fn new_location(&self) -> &Option<ChatLocation> { &self.new_location }
1029
1030}
1031
1032#[doc(hidden)]
1033pub struct RTDChatEventLocationChangedBuilder {
1034 inner: ChatEventLocationChanged
1035}
1036
1037impl RTDChatEventLocationChangedBuilder {
1038 pub fn build(&self) -> ChatEventLocationChanged { self.inner.clone() }
1039
1040
1041 pub fn old_location<T: AsRef<ChatLocation>>(&mut self, old_location: T) -> &mut Self {
1042 self.inner.old_location = Some(old_location.as_ref().clone());
1043 self
1044 }
1045
1046
1047 pub fn new_location<T: AsRef<ChatLocation>>(&mut self, new_location: T) -> &mut Self {
1048 self.inner.new_location = Some(new_location.as_ref().clone());
1049 self
1050 }
1051
1052}
1053
1054impl AsRef<ChatEventLocationChanged> for ChatEventLocationChanged {
1055 fn as_ref(&self) -> &ChatEventLocationChanged { self }
1056}
1057
1058impl AsRef<ChatEventLocationChanged> for RTDChatEventLocationChangedBuilder {
1059 fn as_ref(&self) -> &ChatEventLocationChanged { &self.inner }
1060}
1061
1062
1063
1064
1065
1066
1067
1068#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1070pub struct ChatEventMemberInvited {
1071 #[doc(hidden)]
1072 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1073 td_name: String,
1074 #[doc(hidden)]
1075 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1076 extra: Option<String>,
1077 user_id: i64,
1079 status: ChatMemberStatus,
1081
1082}
1083
1084impl RObject for ChatEventMemberInvited {
1085 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMemberInvited" }
1086 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1087 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1088}
1089
1090
1091impl TDChatEventAction for ChatEventMemberInvited {}
1092
1093
1094
1095impl ChatEventMemberInvited {
1096 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1097 pub fn builder() -> RTDChatEventMemberInvitedBuilder {
1098 let mut inner = ChatEventMemberInvited::default();
1099 inner.td_name = "chatEventMemberInvited".to_string();
1100 inner.extra = Some(Uuid::new_v4().to_string());
1101 RTDChatEventMemberInvitedBuilder { inner }
1102 }
1103
1104 pub fn user_id(&self) -> i64 { self.user_id }
1105
1106 pub fn status(&self) -> &ChatMemberStatus { &self.status }
1107
1108}
1109
1110#[doc(hidden)]
1111pub struct RTDChatEventMemberInvitedBuilder {
1112 inner: ChatEventMemberInvited
1113}
1114
1115impl RTDChatEventMemberInvitedBuilder {
1116 pub fn build(&self) -> ChatEventMemberInvited { self.inner.clone() }
1117
1118
1119 pub fn user_id(&mut self, user_id: i64) -> &mut Self {
1120 self.inner.user_id = user_id;
1121 self
1122 }
1123
1124
1125 pub fn status<T: AsRef<ChatMemberStatus>>(&mut self, status: T) -> &mut Self {
1126 self.inner.status = status.as_ref().clone();
1127 self
1128 }
1129
1130}
1131
1132impl AsRef<ChatEventMemberInvited> for ChatEventMemberInvited {
1133 fn as_ref(&self) -> &ChatEventMemberInvited { self }
1134}
1135
1136impl AsRef<ChatEventMemberInvited> for RTDChatEventMemberInvitedBuilder {
1137 fn as_ref(&self) -> &ChatEventMemberInvited { &self.inner }
1138}
1139
1140
1141
1142
1143
1144
1145
1146#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1148pub struct ChatEventMemberJoined {
1149 #[doc(hidden)]
1150 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1151 td_name: String,
1152 #[doc(hidden)]
1153 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1154 extra: Option<String>,
1155
1156}
1157
1158impl RObject for ChatEventMemberJoined {
1159 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMemberJoined" }
1160 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1161 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1162}
1163
1164
1165impl TDChatEventAction for ChatEventMemberJoined {}
1166
1167
1168
1169impl ChatEventMemberJoined {
1170 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1171 pub fn builder() -> RTDChatEventMemberJoinedBuilder {
1172 let mut inner = ChatEventMemberJoined::default();
1173 inner.td_name = "chatEventMemberJoined".to_string();
1174 inner.extra = Some(Uuid::new_v4().to_string());
1175 RTDChatEventMemberJoinedBuilder { inner }
1176 }
1177
1178}
1179
1180#[doc(hidden)]
1181pub struct RTDChatEventMemberJoinedBuilder {
1182 inner: ChatEventMemberJoined
1183}
1184
1185impl RTDChatEventMemberJoinedBuilder {
1186 pub fn build(&self) -> ChatEventMemberJoined { self.inner.clone() }
1187
1188}
1189
1190impl AsRef<ChatEventMemberJoined> for ChatEventMemberJoined {
1191 fn as_ref(&self) -> &ChatEventMemberJoined { self }
1192}
1193
1194impl AsRef<ChatEventMemberJoined> for RTDChatEventMemberJoinedBuilder {
1195 fn as_ref(&self) -> &ChatEventMemberJoined { &self.inner }
1196}
1197
1198
1199
1200
1201
1202
1203
1204#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1206pub struct ChatEventMemberJoinedByInviteLink {
1207 #[doc(hidden)]
1208 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1209 td_name: String,
1210 #[doc(hidden)]
1211 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1212 extra: Option<String>,
1213 invite_link: ChatInviteLink,
1215
1216}
1217
1218impl RObject for ChatEventMemberJoinedByInviteLink {
1219 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMemberJoinedByInviteLink" }
1220 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1221 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1222}
1223
1224
1225impl TDChatEventAction for ChatEventMemberJoinedByInviteLink {}
1226
1227
1228
1229impl ChatEventMemberJoinedByInviteLink {
1230 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1231 pub fn builder() -> RTDChatEventMemberJoinedByInviteLinkBuilder {
1232 let mut inner = ChatEventMemberJoinedByInviteLink::default();
1233 inner.td_name = "chatEventMemberJoinedByInviteLink".to_string();
1234 inner.extra = Some(Uuid::new_v4().to_string());
1235 RTDChatEventMemberJoinedByInviteLinkBuilder { inner }
1236 }
1237
1238 pub fn invite_link(&self) -> &ChatInviteLink { &self.invite_link }
1239
1240}
1241
1242#[doc(hidden)]
1243pub struct RTDChatEventMemberJoinedByInviteLinkBuilder {
1244 inner: ChatEventMemberJoinedByInviteLink
1245}
1246
1247impl RTDChatEventMemberJoinedByInviteLinkBuilder {
1248 pub fn build(&self) -> ChatEventMemberJoinedByInviteLink { self.inner.clone() }
1249
1250
1251 pub fn invite_link<T: AsRef<ChatInviteLink>>(&mut self, invite_link: T) -> &mut Self {
1252 self.inner.invite_link = invite_link.as_ref().clone();
1253 self
1254 }
1255
1256}
1257
1258impl AsRef<ChatEventMemberJoinedByInviteLink> for ChatEventMemberJoinedByInviteLink {
1259 fn as_ref(&self) -> &ChatEventMemberJoinedByInviteLink { self }
1260}
1261
1262impl AsRef<ChatEventMemberJoinedByInviteLink> for RTDChatEventMemberJoinedByInviteLinkBuilder {
1263 fn as_ref(&self) -> &ChatEventMemberJoinedByInviteLink { &self.inner }
1264}
1265
1266
1267
1268
1269
1270
1271
1272#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1274pub struct ChatEventMemberJoinedByRequest {
1275 #[doc(hidden)]
1276 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1277 td_name: String,
1278 #[doc(hidden)]
1279 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1280 extra: Option<String>,
1281 approver_user_id: i64,
1283 invite_link: Option<ChatInviteLink>,
1285
1286}
1287
1288impl RObject for ChatEventMemberJoinedByRequest {
1289 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMemberJoinedByRequest" }
1290 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1291 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1292}
1293
1294
1295impl TDChatEventAction for ChatEventMemberJoinedByRequest {}
1296
1297
1298
1299impl ChatEventMemberJoinedByRequest {
1300 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1301 pub fn builder() -> RTDChatEventMemberJoinedByRequestBuilder {
1302 let mut inner = ChatEventMemberJoinedByRequest::default();
1303 inner.td_name = "chatEventMemberJoinedByRequest".to_string();
1304 inner.extra = Some(Uuid::new_v4().to_string());
1305 RTDChatEventMemberJoinedByRequestBuilder { inner }
1306 }
1307
1308 pub fn approver_user_id(&self) -> i64 { self.approver_user_id }
1309
1310 pub fn invite_link(&self) -> &Option<ChatInviteLink> { &self.invite_link }
1311
1312}
1313
1314#[doc(hidden)]
1315pub struct RTDChatEventMemberJoinedByRequestBuilder {
1316 inner: ChatEventMemberJoinedByRequest
1317}
1318
1319impl RTDChatEventMemberJoinedByRequestBuilder {
1320 pub fn build(&self) -> ChatEventMemberJoinedByRequest { self.inner.clone() }
1321
1322
1323 pub fn approver_user_id(&mut self, approver_user_id: i64) -> &mut Self {
1324 self.inner.approver_user_id = approver_user_id;
1325 self
1326 }
1327
1328
1329 pub fn invite_link<T: AsRef<ChatInviteLink>>(&mut self, invite_link: T) -> &mut Self {
1330 self.inner.invite_link = Some(invite_link.as_ref().clone());
1331 self
1332 }
1333
1334}
1335
1336impl AsRef<ChatEventMemberJoinedByRequest> for ChatEventMemberJoinedByRequest {
1337 fn as_ref(&self) -> &ChatEventMemberJoinedByRequest { self }
1338}
1339
1340impl AsRef<ChatEventMemberJoinedByRequest> for RTDChatEventMemberJoinedByRequestBuilder {
1341 fn as_ref(&self) -> &ChatEventMemberJoinedByRequest { &self.inner }
1342}
1343
1344
1345
1346
1347
1348
1349
1350#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1352pub struct ChatEventMemberLeft {
1353 #[doc(hidden)]
1354 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1355 td_name: String,
1356 #[doc(hidden)]
1357 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1358 extra: Option<String>,
1359
1360}
1361
1362impl RObject for ChatEventMemberLeft {
1363 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMemberLeft" }
1364 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1365 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1366}
1367
1368
1369impl TDChatEventAction for ChatEventMemberLeft {}
1370
1371
1372
1373impl ChatEventMemberLeft {
1374 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1375 pub fn builder() -> RTDChatEventMemberLeftBuilder {
1376 let mut inner = ChatEventMemberLeft::default();
1377 inner.td_name = "chatEventMemberLeft".to_string();
1378 inner.extra = Some(Uuid::new_v4().to_string());
1379 RTDChatEventMemberLeftBuilder { inner }
1380 }
1381
1382}
1383
1384#[doc(hidden)]
1385pub struct RTDChatEventMemberLeftBuilder {
1386 inner: ChatEventMemberLeft
1387}
1388
1389impl RTDChatEventMemberLeftBuilder {
1390 pub fn build(&self) -> ChatEventMemberLeft { self.inner.clone() }
1391
1392}
1393
1394impl AsRef<ChatEventMemberLeft> for ChatEventMemberLeft {
1395 fn as_ref(&self) -> &ChatEventMemberLeft { self }
1396}
1397
1398impl AsRef<ChatEventMemberLeft> for RTDChatEventMemberLeftBuilder {
1399 fn as_ref(&self) -> &ChatEventMemberLeft { &self.inner }
1400}
1401
1402
1403
1404
1405
1406
1407
1408#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1410pub struct ChatEventMemberPromoted {
1411 #[doc(hidden)]
1412 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1413 td_name: String,
1414 #[doc(hidden)]
1415 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1416 extra: Option<String>,
1417 user_id: i64,
1419 old_status: ChatMemberStatus,
1421 new_status: ChatMemberStatus,
1423
1424}
1425
1426impl RObject for ChatEventMemberPromoted {
1427 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMemberPromoted" }
1428 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1429 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1430}
1431
1432
1433impl TDChatEventAction for ChatEventMemberPromoted {}
1434
1435
1436
1437impl ChatEventMemberPromoted {
1438 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1439 pub fn builder() -> RTDChatEventMemberPromotedBuilder {
1440 let mut inner = ChatEventMemberPromoted::default();
1441 inner.td_name = "chatEventMemberPromoted".to_string();
1442 inner.extra = Some(Uuid::new_v4().to_string());
1443 RTDChatEventMemberPromotedBuilder { inner }
1444 }
1445
1446 pub fn user_id(&self) -> i64 { self.user_id }
1447
1448 pub fn old_status(&self) -> &ChatMemberStatus { &self.old_status }
1449
1450 pub fn new_status(&self) -> &ChatMemberStatus { &self.new_status }
1451
1452}
1453
1454#[doc(hidden)]
1455pub struct RTDChatEventMemberPromotedBuilder {
1456 inner: ChatEventMemberPromoted
1457}
1458
1459impl RTDChatEventMemberPromotedBuilder {
1460 pub fn build(&self) -> ChatEventMemberPromoted { self.inner.clone() }
1461
1462
1463 pub fn user_id(&mut self, user_id: i64) -> &mut Self {
1464 self.inner.user_id = user_id;
1465 self
1466 }
1467
1468
1469 pub fn old_status<T: AsRef<ChatMemberStatus>>(&mut self, old_status: T) -> &mut Self {
1470 self.inner.old_status = old_status.as_ref().clone();
1471 self
1472 }
1473
1474
1475 pub fn new_status<T: AsRef<ChatMemberStatus>>(&mut self, new_status: T) -> &mut Self {
1476 self.inner.new_status = new_status.as_ref().clone();
1477 self
1478 }
1479
1480}
1481
1482impl AsRef<ChatEventMemberPromoted> for ChatEventMemberPromoted {
1483 fn as_ref(&self) -> &ChatEventMemberPromoted { self }
1484}
1485
1486impl AsRef<ChatEventMemberPromoted> for RTDChatEventMemberPromotedBuilder {
1487 fn as_ref(&self) -> &ChatEventMemberPromoted { &self.inner }
1488}
1489
1490
1491
1492
1493
1494
1495
1496#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1498pub struct ChatEventMemberRestricted {
1499 #[doc(hidden)]
1500 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1501 td_name: String,
1502 #[doc(hidden)]
1503 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1504 extra: Option<String>,
1505 member_id: MessageSender,
1507 old_status: ChatMemberStatus,
1509 new_status: ChatMemberStatus,
1511
1512}
1513
1514impl RObject for ChatEventMemberRestricted {
1515 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMemberRestricted" }
1516 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1517 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1518}
1519
1520
1521impl TDChatEventAction for ChatEventMemberRestricted {}
1522
1523
1524
1525impl ChatEventMemberRestricted {
1526 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1527 pub fn builder() -> RTDChatEventMemberRestrictedBuilder {
1528 let mut inner = ChatEventMemberRestricted::default();
1529 inner.td_name = "chatEventMemberRestricted".to_string();
1530 inner.extra = Some(Uuid::new_v4().to_string());
1531 RTDChatEventMemberRestrictedBuilder { inner }
1532 }
1533
1534 pub fn member_id(&self) -> &MessageSender { &self.member_id }
1535
1536 pub fn old_status(&self) -> &ChatMemberStatus { &self.old_status }
1537
1538 pub fn new_status(&self) -> &ChatMemberStatus { &self.new_status }
1539
1540}
1541
1542#[doc(hidden)]
1543pub struct RTDChatEventMemberRestrictedBuilder {
1544 inner: ChatEventMemberRestricted
1545}
1546
1547impl RTDChatEventMemberRestrictedBuilder {
1548 pub fn build(&self) -> ChatEventMemberRestricted { self.inner.clone() }
1549
1550
1551 pub fn member_id<T: AsRef<MessageSender>>(&mut self, member_id: T) -> &mut Self {
1552 self.inner.member_id = member_id.as_ref().clone();
1553 self
1554 }
1555
1556
1557 pub fn old_status<T: AsRef<ChatMemberStatus>>(&mut self, old_status: T) -> &mut Self {
1558 self.inner.old_status = old_status.as_ref().clone();
1559 self
1560 }
1561
1562
1563 pub fn new_status<T: AsRef<ChatMemberStatus>>(&mut self, new_status: T) -> &mut Self {
1564 self.inner.new_status = new_status.as_ref().clone();
1565 self
1566 }
1567
1568}
1569
1570impl AsRef<ChatEventMemberRestricted> for ChatEventMemberRestricted {
1571 fn as_ref(&self) -> &ChatEventMemberRestricted { self }
1572}
1573
1574impl AsRef<ChatEventMemberRestricted> for RTDChatEventMemberRestrictedBuilder {
1575 fn as_ref(&self) -> &ChatEventMemberRestricted { &self.inner }
1576}
1577
1578
1579
1580
1581
1582
1583
1584#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1586pub struct ChatEventMessageDeleted {
1587 #[doc(hidden)]
1588 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1589 td_name: String,
1590 #[doc(hidden)]
1591 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1592 extra: Option<String>,
1593 message: Message,
1595
1596}
1597
1598impl RObject for ChatEventMessageDeleted {
1599 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMessageDeleted" }
1600 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1601 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1602}
1603
1604
1605impl TDChatEventAction for ChatEventMessageDeleted {}
1606
1607
1608
1609impl ChatEventMessageDeleted {
1610 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1611 pub fn builder() -> RTDChatEventMessageDeletedBuilder {
1612 let mut inner = ChatEventMessageDeleted::default();
1613 inner.td_name = "chatEventMessageDeleted".to_string();
1614 inner.extra = Some(Uuid::new_v4().to_string());
1615 RTDChatEventMessageDeletedBuilder { inner }
1616 }
1617
1618 pub fn message(&self) -> &Message { &self.message }
1619
1620}
1621
1622#[doc(hidden)]
1623pub struct RTDChatEventMessageDeletedBuilder {
1624 inner: ChatEventMessageDeleted
1625}
1626
1627impl RTDChatEventMessageDeletedBuilder {
1628 pub fn build(&self) -> ChatEventMessageDeleted { self.inner.clone() }
1629
1630
1631 pub fn message<T: AsRef<Message>>(&mut self, message: T) -> &mut Self {
1632 self.inner.message = message.as_ref().clone();
1633 self
1634 }
1635
1636}
1637
1638impl AsRef<ChatEventMessageDeleted> for ChatEventMessageDeleted {
1639 fn as_ref(&self) -> &ChatEventMessageDeleted { self }
1640}
1641
1642impl AsRef<ChatEventMessageDeleted> for RTDChatEventMessageDeletedBuilder {
1643 fn as_ref(&self) -> &ChatEventMessageDeleted { &self.inner }
1644}
1645
1646
1647
1648
1649
1650
1651
1652#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1654pub struct ChatEventMessageEdited {
1655 #[doc(hidden)]
1656 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1657 td_name: String,
1658 #[doc(hidden)]
1659 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1660 extra: Option<String>,
1661 old_message: Message,
1663 new_message: Message,
1665
1666}
1667
1668impl RObject for ChatEventMessageEdited {
1669 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMessageEdited" }
1670 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1671 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1672}
1673
1674
1675impl TDChatEventAction for ChatEventMessageEdited {}
1676
1677
1678
1679impl ChatEventMessageEdited {
1680 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1681 pub fn builder() -> RTDChatEventMessageEditedBuilder {
1682 let mut inner = ChatEventMessageEdited::default();
1683 inner.td_name = "chatEventMessageEdited".to_string();
1684 inner.extra = Some(Uuid::new_v4().to_string());
1685 RTDChatEventMessageEditedBuilder { inner }
1686 }
1687
1688 pub fn old_message(&self) -> &Message { &self.old_message }
1689
1690 pub fn new_message(&self) -> &Message { &self.new_message }
1691
1692}
1693
1694#[doc(hidden)]
1695pub struct RTDChatEventMessageEditedBuilder {
1696 inner: ChatEventMessageEdited
1697}
1698
1699impl RTDChatEventMessageEditedBuilder {
1700 pub fn build(&self) -> ChatEventMessageEdited { self.inner.clone() }
1701
1702
1703 pub fn old_message<T: AsRef<Message>>(&mut self, old_message: T) -> &mut Self {
1704 self.inner.old_message = old_message.as_ref().clone();
1705 self
1706 }
1707
1708
1709 pub fn new_message<T: AsRef<Message>>(&mut self, new_message: T) -> &mut Self {
1710 self.inner.new_message = new_message.as_ref().clone();
1711 self
1712 }
1713
1714}
1715
1716impl AsRef<ChatEventMessageEdited> for ChatEventMessageEdited {
1717 fn as_ref(&self) -> &ChatEventMessageEdited { self }
1718}
1719
1720impl AsRef<ChatEventMessageEdited> for RTDChatEventMessageEditedBuilder {
1721 fn as_ref(&self) -> &ChatEventMessageEdited { &self.inner }
1722}
1723
1724
1725
1726
1727
1728
1729
1730#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1732pub struct ChatEventMessagePinned {
1733 #[doc(hidden)]
1734 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1735 td_name: String,
1736 #[doc(hidden)]
1737 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1738 extra: Option<String>,
1739 message: Message,
1741
1742}
1743
1744impl RObject for ChatEventMessagePinned {
1745 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMessagePinned" }
1746 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1747 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1748}
1749
1750
1751impl TDChatEventAction for ChatEventMessagePinned {}
1752
1753
1754
1755impl ChatEventMessagePinned {
1756 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1757 pub fn builder() -> RTDChatEventMessagePinnedBuilder {
1758 let mut inner = ChatEventMessagePinned::default();
1759 inner.td_name = "chatEventMessagePinned".to_string();
1760 inner.extra = Some(Uuid::new_v4().to_string());
1761 RTDChatEventMessagePinnedBuilder { inner }
1762 }
1763
1764 pub fn message(&self) -> &Message { &self.message }
1765
1766}
1767
1768#[doc(hidden)]
1769pub struct RTDChatEventMessagePinnedBuilder {
1770 inner: ChatEventMessagePinned
1771}
1772
1773impl RTDChatEventMessagePinnedBuilder {
1774 pub fn build(&self) -> ChatEventMessagePinned { self.inner.clone() }
1775
1776
1777 pub fn message<T: AsRef<Message>>(&mut self, message: T) -> &mut Self {
1778 self.inner.message = message.as_ref().clone();
1779 self
1780 }
1781
1782}
1783
1784impl AsRef<ChatEventMessagePinned> for ChatEventMessagePinned {
1785 fn as_ref(&self) -> &ChatEventMessagePinned { self }
1786}
1787
1788impl AsRef<ChatEventMessagePinned> for RTDChatEventMessagePinnedBuilder {
1789 fn as_ref(&self) -> &ChatEventMessagePinned { &self.inner }
1790}
1791
1792
1793
1794
1795
1796
1797
1798#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1800pub struct ChatEventMessageTtlChanged {
1801 #[doc(hidden)]
1802 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1803 td_name: String,
1804 #[doc(hidden)]
1805 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1806 extra: Option<String>,
1807 old_message_ttl: i64,
1809 new_message_ttl: i64,
1811
1812}
1813
1814impl RObject for ChatEventMessageTtlChanged {
1815 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMessageTtlChanged" }
1816 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1817 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1818}
1819
1820
1821impl TDChatEventAction for ChatEventMessageTtlChanged {}
1822
1823
1824
1825impl ChatEventMessageTtlChanged {
1826 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1827 pub fn builder() -> RTDChatEventMessageTtlChangedBuilder {
1828 let mut inner = ChatEventMessageTtlChanged::default();
1829 inner.td_name = "chatEventMessageTtlChanged".to_string();
1830 inner.extra = Some(Uuid::new_v4().to_string());
1831 RTDChatEventMessageTtlChangedBuilder { inner }
1832 }
1833
1834 pub fn old_message_ttl(&self) -> i64 { self.old_message_ttl }
1835
1836 pub fn new_message_ttl(&self) -> i64 { self.new_message_ttl }
1837
1838}
1839
1840#[doc(hidden)]
1841pub struct RTDChatEventMessageTtlChangedBuilder {
1842 inner: ChatEventMessageTtlChanged
1843}
1844
1845impl RTDChatEventMessageTtlChangedBuilder {
1846 pub fn build(&self) -> ChatEventMessageTtlChanged { self.inner.clone() }
1847
1848
1849 pub fn old_message_ttl(&mut self, old_message_ttl: i64) -> &mut Self {
1850 self.inner.old_message_ttl = old_message_ttl;
1851 self
1852 }
1853
1854
1855 pub fn new_message_ttl(&mut self, new_message_ttl: i64) -> &mut Self {
1856 self.inner.new_message_ttl = new_message_ttl;
1857 self
1858 }
1859
1860}
1861
1862impl AsRef<ChatEventMessageTtlChanged> for ChatEventMessageTtlChanged {
1863 fn as_ref(&self) -> &ChatEventMessageTtlChanged { self }
1864}
1865
1866impl AsRef<ChatEventMessageTtlChanged> for RTDChatEventMessageTtlChangedBuilder {
1867 fn as_ref(&self) -> &ChatEventMessageTtlChanged { &self.inner }
1868}
1869
1870
1871
1872
1873
1874
1875
1876#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1878pub struct ChatEventMessageUnpinned {
1879 #[doc(hidden)]
1880 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1881 td_name: String,
1882 #[doc(hidden)]
1883 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1884 extra: Option<String>,
1885 message: Message,
1887
1888}
1889
1890impl RObject for ChatEventMessageUnpinned {
1891 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventMessageUnpinned" }
1892 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1893 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1894}
1895
1896
1897impl TDChatEventAction for ChatEventMessageUnpinned {}
1898
1899
1900
1901impl ChatEventMessageUnpinned {
1902 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1903 pub fn builder() -> RTDChatEventMessageUnpinnedBuilder {
1904 let mut inner = ChatEventMessageUnpinned::default();
1905 inner.td_name = "chatEventMessageUnpinned".to_string();
1906 inner.extra = Some(Uuid::new_v4().to_string());
1907 RTDChatEventMessageUnpinnedBuilder { inner }
1908 }
1909
1910 pub fn message(&self) -> &Message { &self.message }
1911
1912}
1913
1914#[doc(hidden)]
1915pub struct RTDChatEventMessageUnpinnedBuilder {
1916 inner: ChatEventMessageUnpinned
1917}
1918
1919impl RTDChatEventMessageUnpinnedBuilder {
1920 pub fn build(&self) -> ChatEventMessageUnpinned { self.inner.clone() }
1921
1922
1923 pub fn message<T: AsRef<Message>>(&mut self, message: T) -> &mut Self {
1924 self.inner.message = message.as_ref().clone();
1925 self
1926 }
1927
1928}
1929
1930impl AsRef<ChatEventMessageUnpinned> for ChatEventMessageUnpinned {
1931 fn as_ref(&self) -> &ChatEventMessageUnpinned { self }
1932}
1933
1934impl AsRef<ChatEventMessageUnpinned> for RTDChatEventMessageUnpinnedBuilder {
1935 fn as_ref(&self) -> &ChatEventMessageUnpinned { &self.inner }
1936}
1937
1938
1939
1940
1941
1942
1943
1944#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1946pub struct ChatEventPermissionsChanged {
1947 #[doc(hidden)]
1948 #[serde(rename(serialize = "@type", deserialize = "@type"))]
1949 td_name: String,
1950 #[doc(hidden)]
1951 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1952 extra: Option<String>,
1953 old_permissions: ChatPermissions,
1955 new_permissions: ChatPermissions,
1957
1958}
1959
1960impl RObject for ChatEventPermissionsChanged {
1961 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventPermissionsChanged" }
1962 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
1963 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
1964}
1965
1966
1967impl TDChatEventAction for ChatEventPermissionsChanged {}
1968
1969
1970
1971impl ChatEventPermissionsChanged {
1972 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
1973 pub fn builder() -> RTDChatEventPermissionsChangedBuilder {
1974 let mut inner = ChatEventPermissionsChanged::default();
1975 inner.td_name = "chatEventPermissionsChanged".to_string();
1976 inner.extra = Some(Uuid::new_v4().to_string());
1977 RTDChatEventPermissionsChangedBuilder { inner }
1978 }
1979
1980 pub fn old_permissions(&self) -> &ChatPermissions { &self.old_permissions }
1981
1982 pub fn new_permissions(&self) -> &ChatPermissions { &self.new_permissions }
1983
1984}
1985
1986#[doc(hidden)]
1987pub struct RTDChatEventPermissionsChangedBuilder {
1988 inner: ChatEventPermissionsChanged
1989}
1990
1991impl RTDChatEventPermissionsChangedBuilder {
1992 pub fn build(&self) -> ChatEventPermissionsChanged { self.inner.clone() }
1993
1994
1995 pub fn old_permissions<T: AsRef<ChatPermissions>>(&mut self, old_permissions: T) -> &mut Self {
1996 self.inner.old_permissions = old_permissions.as_ref().clone();
1997 self
1998 }
1999
2000
2001 pub fn new_permissions<T: AsRef<ChatPermissions>>(&mut self, new_permissions: T) -> &mut Self {
2002 self.inner.new_permissions = new_permissions.as_ref().clone();
2003 self
2004 }
2005
2006}
2007
2008impl AsRef<ChatEventPermissionsChanged> for ChatEventPermissionsChanged {
2009 fn as_ref(&self) -> &ChatEventPermissionsChanged { self }
2010}
2011
2012impl AsRef<ChatEventPermissionsChanged> for RTDChatEventPermissionsChangedBuilder {
2013 fn as_ref(&self) -> &ChatEventPermissionsChanged { &self.inner }
2014}
2015
2016
2017
2018
2019
2020
2021
2022#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2024pub struct ChatEventPhotoChanged {
2025 #[doc(hidden)]
2026 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2027 td_name: String,
2028 #[doc(hidden)]
2029 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2030 extra: Option<String>,
2031 old_photo: Option<ChatPhoto>,
2033 new_photo: Option<ChatPhoto>,
2035
2036}
2037
2038impl RObject for ChatEventPhotoChanged {
2039 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventPhotoChanged" }
2040 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2041 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2042}
2043
2044
2045impl TDChatEventAction for ChatEventPhotoChanged {}
2046
2047
2048
2049impl ChatEventPhotoChanged {
2050 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2051 pub fn builder() -> RTDChatEventPhotoChangedBuilder {
2052 let mut inner = ChatEventPhotoChanged::default();
2053 inner.td_name = "chatEventPhotoChanged".to_string();
2054 inner.extra = Some(Uuid::new_v4().to_string());
2055 RTDChatEventPhotoChangedBuilder { inner }
2056 }
2057
2058 pub fn old_photo(&self) -> &Option<ChatPhoto> { &self.old_photo }
2059
2060 pub fn new_photo(&self) -> &Option<ChatPhoto> { &self.new_photo }
2061
2062}
2063
2064#[doc(hidden)]
2065pub struct RTDChatEventPhotoChangedBuilder {
2066 inner: ChatEventPhotoChanged
2067}
2068
2069impl RTDChatEventPhotoChangedBuilder {
2070 pub fn build(&self) -> ChatEventPhotoChanged { self.inner.clone() }
2071
2072
2073 pub fn old_photo<T: AsRef<ChatPhoto>>(&mut self, old_photo: T) -> &mut Self {
2074 self.inner.old_photo = Some(old_photo.as_ref().clone());
2075 self
2076 }
2077
2078
2079 pub fn new_photo<T: AsRef<ChatPhoto>>(&mut self, new_photo: T) -> &mut Self {
2080 self.inner.new_photo = Some(new_photo.as_ref().clone());
2081 self
2082 }
2083
2084}
2085
2086impl AsRef<ChatEventPhotoChanged> for ChatEventPhotoChanged {
2087 fn as_ref(&self) -> &ChatEventPhotoChanged { self }
2088}
2089
2090impl AsRef<ChatEventPhotoChanged> for RTDChatEventPhotoChangedBuilder {
2091 fn as_ref(&self) -> &ChatEventPhotoChanged { &self.inner }
2092}
2093
2094
2095
2096
2097
2098
2099
2100#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2102pub struct ChatEventPollStopped {
2103 #[doc(hidden)]
2104 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2105 td_name: String,
2106 #[doc(hidden)]
2107 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2108 extra: Option<String>,
2109 message: Message,
2111
2112}
2113
2114impl RObject for ChatEventPollStopped {
2115 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventPollStopped" }
2116 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2117 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2118}
2119
2120
2121impl TDChatEventAction for ChatEventPollStopped {}
2122
2123
2124
2125impl ChatEventPollStopped {
2126 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2127 pub fn builder() -> RTDChatEventPollStoppedBuilder {
2128 let mut inner = ChatEventPollStopped::default();
2129 inner.td_name = "chatEventPollStopped".to_string();
2130 inner.extra = Some(Uuid::new_v4().to_string());
2131 RTDChatEventPollStoppedBuilder { inner }
2132 }
2133
2134 pub fn message(&self) -> &Message { &self.message }
2135
2136}
2137
2138#[doc(hidden)]
2139pub struct RTDChatEventPollStoppedBuilder {
2140 inner: ChatEventPollStopped
2141}
2142
2143impl RTDChatEventPollStoppedBuilder {
2144 pub fn build(&self) -> ChatEventPollStopped { self.inner.clone() }
2145
2146
2147 pub fn message<T: AsRef<Message>>(&mut self, message: T) -> &mut Self {
2148 self.inner.message = message.as_ref().clone();
2149 self
2150 }
2151
2152}
2153
2154impl AsRef<ChatEventPollStopped> for ChatEventPollStopped {
2155 fn as_ref(&self) -> &ChatEventPollStopped { self }
2156}
2157
2158impl AsRef<ChatEventPollStopped> for RTDChatEventPollStoppedBuilder {
2159 fn as_ref(&self) -> &ChatEventPollStopped { &self.inner }
2160}
2161
2162
2163
2164
2165
2166
2167
2168#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2170pub struct ChatEventSignMessagesToggled {
2171 #[doc(hidden)]
2172 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2173 td_name: String,
2174 #[doc(hidden)]
2175 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2176 extra: Option<String>,
2177 sign_messages: bool,
2179
2180}
2181
2182impl RObject for ChatEventSignMessagesToggled {
2183 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventSignMessagesToggled" }
2184 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2185 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2186}
2187
2188
2189impl TDChatEventAction for ChatEventSignMessagesToggled {}
2190
2191
2192
2193impl ChatEventSignMessagesToggled {
2194 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2195 pub fn builder() -> RTDChatEventSignMessagesToggledBuilder {
2196 let mut inner = ChatEventSignMessagesToggled::default();
2197 inner.td_name = "chatEventSignMessagesToggled".to_string();
2198 inner.extra = Some(Uuid::new_v4().to_string());
2199 RTDChatEventSignMessagesToggledBuilder { inner }
2200 }
2201
2202 pub fn sign_messages(&self) -> bool { self.sign_messages }
2203
2204}
2205
2206#[doc(hidden)]
2207pub struct RTDChatEventSignMessagesToggledBuilder {
2208 inner: ChatEventSignMessagesToggled
2209}
2210
2211impl RTDChatEventSignMessagesToggledBuilder {
2212 pub fn build(&self) -> ChatEventSignMessagesToggled { self.inner.clone() }
2213
2214
2215 pub fn sign_messages(&mut self, sign_messages: bool) -> &mut Self {
2216 self.inner.sign_messages = sign_messages;
2217 self
2218 }
2219
2220}
2221
2222impl AsRef<ChatEventSignMessagesToggled> for ChatEventSignMessagesToggled {
2223 fn as_ref(&self) -> &ChatEventSignMessagesToggled { self }
2224}
2225
2226impl AsRef<ChatEventSignMessagesToggled> for RTDChatEventSignMessagesToggledBuilder {
2227 fn as_ref(&self) -> &ChatEventSignMessagesToggled { &self.inner }
2228}
2229
2230
2231
2232
2233
2234
2235
2236#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2238pub struct ChatEventSlowModeDelayChanged {
2239 #[doc(hidden)]
2240 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2241 td_name: String,
2242 #[doc(hidden)]
2243 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2244 extra: Option<String>,
2245 old_slow_mode_delay: i64,
2247 new_slow_mode_delay: i64,
2249
2250}
2251
2252impl RObject for ChatEventSlowModeDelayChanged {
2253 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventSlowModeDelayChanged" }
2254 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2255 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2256}
2257
2258
2259impl TDChatEventAction for ChatEventSlowModeDelayChanged {}
2260
2261
2262
2263impl ChatEventSlowModeDelayChanged {
2264 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2265 pub fn builder() -> RTDChatEventSlowModeDelayChangedBuilder {
2266 let mut inner = ChatEventSlowModeDelayChanged::default();
2267 inner.td_name = "chatEventSlowModeDelayChanged".to_string();
2268 inner.extra = Some(Uuid::new_v4().to_string());
2269 RTDChatEventSlowModeDelayChangedBuilder { inner }
2270 }
2271
2272 pub fn old_slow_mode_delay(&self) -> i64 { self.old_slow_mode_delay }
2273
2274 pub fn new_slow_mode_delay(&self) -> i64 { self.new_slow_mode_delay }
2275
2276}
2277
2278#[doc(hidden)]
2279pub struct RTDChatEventSlowModeDelayChangedBuilder {
2280 inner: ChatEventSlowModeDelayChanged
2281}
2282
2283impl RTDChatEventSlowModeDelayChangedBuilder {
2284 pub fn build(&self) -> ChatEventSlowModeDelayChanged { self.inner.clone() }
2285
2286
2287 pub fn old_slow_mode_delay(&mut self, old_slow_mode_delay: i64) -> &mut Self {
2288 self.inner.old_slow_mode_delay = old_slow_mode_delay;
2289 self
2290 }
2291
2292
2293 pub fn new_slow_mode_delay(&mut self, new_slow_mode_delay: i64) -> &mut Self {
2294 self.inner.new_slow_mode_delay = new_slow_mode_delay;
2295 self
2296 }
2297
2298}
2299
2300impl AsRef<ChatEventSlowModeDelayChanged> for ChatEventSlowModeDelayChanged {
2301 fn as_ref(&self) -> &ChatEventSlowModeDelayChanged { self }
2302}
2303
2304impl AsRef<ChatEventSlowModeDelayChanged> for RTDChatEventSlowModeDelayChangedBuilder {
2305 fn as_ref(&self) -> &ChatEventSlowModeDelayChanged { &self.inner }
2306}
2307
2308
2309
2310
2311
2312
2313
2314#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2316pub struct ChatEventStickerSetChanged {
2317 #[doc(hidden)]
2318 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2319 td_name: String,
2320 #[doc(hidden)]
2321 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2322 extra: Option<String>,
2323 old_sticker_set_id: isize,
2325 new_sticker_set_id: isize,
2327
2328}
2329
2330impl RObject for ChatEventStickerSetChanged {
2331 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventStickerSetChanged" }
2332 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2333 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2334}
2335
2336
2337impl TDChatEventAction for ChatEventStickerSetChanged {}
2338
2339
2340
2341impl ChatEventStickerSetChanged {
2342 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2343 pub fn builder() -> RTDChatEventStickerSetChangedBuilder {
2344 let mut inner = ChatEventStickerSetChanged::default();
2345 inner.td_name = "chatEventStickerSetChanged".to_string();
2346 inner.extra = Some(Uuid::new_v4().to_string());
2347 RTDChatEventStickerSetChangedBuilder { inner }
2348 }
2349
2350 pub fn old_sticker_set_id(&self) -> isize { self.old_sticker_set_id }
2351
2352 pub fn new_sticker_set_id(&self) -> isize { self.new_sticker_set_id }
2353
2354}
2355
2356#[doc(hidden)]
2357pub struct RTDChatEventStickerSetChangedBuilder {
2358 inner: ChatEventStickerSetChanged
2359}
2360
2361impl RTDChatEventStickerSetChangedBuilder {
2362 pub fn build(&self) -> ChatEventStickerSetChanged { self.inner.clone() }
2363
2364
2365 pub fn old_sticker_set_id(&mut self, old_sticker_set_id: isize) -> &mut Self {
2366 self.inner.old_sticker_set_id = old_sticker_set_id;
2367 self
2368 }
2369
2370
2371 pub fn new_sticker_set_id(&mut self, new_sticker_set_id: isize) -> &mut Self {
2372 self.inner.new_sticker_set_id = new_sticker_set_id;
2373 self
2374 }
2375
2376}
2377
2378impl AsRef<ChatEventStickerSetChanged> for ChatEventStickerSetChanged {
2379 fn as_ref(&self) -> &ChatEventStickerSetChanged { self }
2380}
2381
2382impl AsRef<ChatEventStickerSetChanged> for RTDChatEventStickerSetChangedBuilder {
2383 fn as_ref(&self) -> &ChatEventStickerSetChanged { &self.inner }
2384}
2385
2386
2387
2388
2389
2390
2391
2392#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2394pub struct ChatEventTitleChanged {
2395 #[doc(hidden)]
2396 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2397 td_name: String,
2398 #[doc(hidden)]
2399 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2400 extra: Option<String>,
2401 old_title: String,
2403 new_title: String,
2405
2406}
2407
2408impl RObject for ChatEventTitleChanged {
2409 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventTitleChanged" }
2410 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2411 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2412}
2413
2414
2415impl TDChatEventAction for ChatEventTitleChanged {}
2416
2417
2418
2419impl ChatEventTitleChanged {
2420 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2421 pub fn builder() -> RTDChatEventTitleChangedBuilder {
2422 let mut inner = ChatEventTitleChanged::default();
2423 inner.td_name = "chatEventTitleChanged".to_string();
2424 inner.extra = Some(Uuid::new_v4().to_string());
2425 RTDChatEventTitleChangedBuilder { inner }
2426 }
2427
2428 pub fn old_title(&self) -> &String { &self.old_title }
2429
2430 pub fn new_title(&self) -> &String { &self.new_title }
2431
2432}
2433
2434#[doc(hidden)]
2435pub struct RTDChatEventTitleChangedBuilder {
2436 inner: ChatEventTitleChanged
2437}
2438
2439impl RTDChatEventTitleChangedBuilder {
2440 pub fn build(&self) -> ChatEventTitleChanged { self.inner.clone() }
2441
2442
2443 pub fn old_title<T: AsRef<str>>(&mut self, old_title: T) -> &mut Self {
2444 self.inner.old_title = old_title.as_ref().to_string();
2445 self
2446 }
2447
2448
2449 pub fn new_title<T: AsRef<str>>(&mut self, new_title: T) -> &mut Self {
2450 self.inner.new_title = new_title.as_ref().to_string();
2451 self
2452 }
2453
2454}
2455
2456impl AsRef<ChatEventTitleChanged> for ChatEventTitleChanged {
2457 fn as_ref(&self) -> &ChatEventTitleChanged { self }
2458}
2459
2460impl AsRef<ChatEventTitleChanged> for RTDChatEventTitleChangedBuilder {
2461 fn as_ref(&self) -> &ChatEventTitleChanged { &self.inner }
2462}
2463
2464
2465
2466
2467
2468
2469
2470#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2472pub struct ChatEventUsernameChanged {
2473 #[doc(hidden)]
2474 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2475 td_name: String,
2476 #[doc(hidden)]
2477 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2478 extra: Option<String>,
2479 old_username: String,
2481 new_username: String,
2483
2484}
2485
2486impl RObject for ChatEventUsernameChanged {
2487 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventUsernameChanged" }
2488 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2489 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2490}
2491
2492
2493impl TDChatEventAction for ChatEventUsernameChanged {}
2494
2495
2496
2497impl ChatEventUsernameChanged {
2498 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2499 pub fn builder() -> RTDChatEventUsernameChangedBuilder {
2500 let mut inner = ChatEventUsernameChanged::default();
2501 inner.td_name = "chatEventUsernameChanged".to_string();
2502 inner.extra = Some(Uuid::new_v4().to_string());
2503 RTDChatEventUsernameChangedBuilder { inner }
2504 }
2505
2506 pub fn old_username(&self) -> &String { &self.old_username }
2507
2508 pub fn new_username(&self) -> &String { &self.new_username }
2509
2510}
2511
2512#[doc(hidden)]
2513pub struct RTDChatEventUsernameChangedBuilder {
2514 inner: ChatEventUsernameChanged
2515}
2516
2517impl RTDChatEventUsernameChangedBuilder {
2518 pub fn build(&self) -> ChatEventUsernameChanged { self.inner.clone() }
2519
2520
2521 pub fn old_username<T: AsRef<str>>(&mut self, old_username: T) -> &mut Self {
2522 self.inner.old_username = old_username.as_ref().to_string();
2523 self
2524 }
2525
2526
2527 pub fn new_username<T: AsRef<str>>(&mut self, new_username: T) -> &mut Self {
2528 self.inner.new_username = new_username.as_ref().to_string();
2529 self
2530 }
2531
2532}
2533
2534impl AsRef<ChatEventUsernameChanged> for ChatEventUsernameChanged {
2535 fn as_ref(&self) -> &ChatEventUsernameChanged { self }
2536}
2537
2538impl AsRef<ChatEventUsernameChanged> for RTDChatEventUsernameChangedBuilder {
2539 fn as_ref(&self) -> &ChatEventUsernameChanged { &self.inner }
2540}
2541
2542
2543
2544
2545
2546
2547
2548#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2550pub struct ChatEventVideoChatCreated {
2551 #[doc(hidden)]
2552 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2553 td_name: String,
2554 #[doc(hidden)]
2555 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2556 extra: Option<String>,
2557 group_call_id: i64,
2559
2560}
2561
2562impl RObject for ChatEventVideoChatCreated {
2563 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventVideoChatCreated" }
2564 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2565 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2566}
2567
2568
2569impl TDChatEventAction for ChatEventVideoChatCreated {}
2570
2571
2572
2573impl ChatEventVideoChatCreated {
2574 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2575 pub fn builder() -> RTDChatEventVideoChatCreatedBuilder {
2576 let mut inner = ChatEventVideoChatCreated::default();
2577 inner.td_name = "chatEventVideoChatCreated".to_string();
2578 inner.extra = Some(Uuid::new_v4().to_string());
2579 RTDChatEventVideoChatCreatedBuilder { inner }
2580 }
2581
2582 pub fn group_call_id(&self) -> i64 { self.group_call_id }
2583
2584}
2585
2586#[doc(hidden)]
2587pub struct RTDChatEventVideoChatCreatedBuilder {
2588 inner: ChatEventVideoChatCreated
2589}
2590
2591impl RTDChatEventVideoChatCreatedBuilder {
2592 pub fn build(&self) -> ChatEventVideoChatCreated { self.inner.clone() }
2593
2594
2595 pub fn group_call_id(&mut self, group_call_id: i64) -> &mut Self {
2596 self.inner.group_call_id = group_call_id;
2597 self
2598 }
2599
2600}
2601
2602impl AsRef<ChatEventVideoChatCreated> for ChatEventVideoChatCreated {
2603 fn as_ref(&self) -> &ChatEventVideoChatCreated { self }
2604}
2605
2606impl AsRef<ChatEventVideoChatCreated> for RTDChatEventVideoChatCreatedBuilder {
2607 fn as_ref(&self) -> &ChatEventVideoChatCreated { &self.inner }
2608}
2609
2610
2611
2612
2613
2614
2615
2616#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2618pub struct ChatEventVideoChatEnded {
2619 #[doc(hidden)]
2620 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2621 td_name: String,
2622 #[doc(hidden)]
2623 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2624 extra: Option<String>,
2625 group_call_id: i64,
2627
2628}
2629
2630impl RObject for ChatEventVideoChatEnded {
2631 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventVideoChatEnded" }
2632 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2633 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2634}
2635
2636
2637impl TDChatEventAction for ChatEventVideoChatEnded {}
2638
2639
2640
2641impl ChatEventVideoChatEnded {
2642 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2643 pub fn builder() -> RTDChatEventVideoChatEndedBuilder {
2644 let mut inner = ChatEventVideoChatEnded::default();
2645 inner.td_name = "chatEventVideoChatEnded".to_string();
2646 inner.extra = Some(Uuid::new_v4().to_string());
2647 RTDChatEventVideoChatEndedBuilder { inner }
2648 }
2649
2650 pub fn group_call_id(&self) -> i64 { self.group_call_id }
2651
2652}
2653
2654#[doc(hidden)]
2655pub struct RTDChatEventVideoChatEndedBuilder {
2656 inner: ChatEventVideoChatEnded
2657}
2658
2659impl RTDChatEventVideoChatEndedBuilder {
2660 pub fn build(&self) -> ChatEventVideoChatEnded { self.inner.clone() }
2661
2662
2663 pub fn group_call_id(&mut self, group_call_id: i64) -> &mut Self {
2664 self.inner.group_call_id = group_call_id;
2665 self
2666 }
2667
2668}
2669
2670impl AsRef<ChatEventVideoChatEnded> for ChatEventVideoChatEnded {
2671 fn as_ref(&self) -> &ChatEventVideoChatEnded { self }
2672}
2673
2674impl AsRef<ChatEventVideoChatEnded> for RTDChatEventVideoChatEndedBuilder {
2675 fn as_ref(&self) -> &ChatEventVideoChatEnded { &self.inner }
2676}
2677
2678
2679
2680
2681
2682
2683
2684#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2686pub struct ChatEventVideoChatMuteNewParticipantsToggled {
2687 #[doc(hidden)]
2688 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2689 td_name: String,
2690 #[doc(hidden)]
2691 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2692 extra: Option<String>,
2693 mute_new_participants: bool,
2695
2696}
2697
2698impl RObject for ChatEventVideoChatMuteNewParticipantsToggled {
2699 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventVideoChatMuteNewParticipantsToggled" }
2700 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2701 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2702}
2703
2704
2705impl TDChatEventAction for ChatEventVideoChatMuteNewParticipantsToggled {}
2706
2707
2708
2709impl ChatEventVideoChatMuteNewParticipantsToggled {
2710 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2711 pub fn builder() -> RTDChatEventVideoChatMuteNewParticipantsToggledBuilder {
2712 let mut inner = ChatEventVideoChatMuteNewParticipantsToggled::default();
2713 inner.td_name = "chatEventVideoChatMuteNewParticipantsToggled".to_string();
2714 inner.extra = Some(Uuid::new_v4().to_string());
2715 RTDChatEventVideoChatMuteNewParticipantsToggledBuilder { inner }
2716 }
2717
2718 pub fn mute_new_participants(&self) -> bool { self.mute_new_participants }
2719
2720}
2721
2722#[doc(hidden)]
2723pub struct RTDChatEventVideoChatMuteNewParticipantsToggledBuilder {
2724 inner: ChatEventVideoChatMuteNewParticipantsToggled
2725}
2726
2727impl RTDChatEventVideoChatMuteNewParticipantsToggledBuilder {
2728 pub fn build(&self) -> ChatEventVideoChatMuteNewParticipantsToggled { self.inner.clone() }
2729
2730
2731 pub fn mute_new_participants(&mut self, mute_new_participants: bool) -> &mut Self {
2732 self.inner.mute_new_participants = mute_new_participants;
2733 self
2734 }
2735
2736}
2737
2738impl AsRef<ChatEventVideoChatMuteNewParticipantsToggled> for ChatEventVideoChatMuteNewParticipantsToggled {
2739 fn as_ref(&self) -> &ChatEventVideoChatMuteNewParticipantsToggled { self }
2740}
2741
2742impl AsRef<ChatEventVideoChatMuteNewParticipantsToggled> for RTDChatEventVideoChatMuteNewParticipantsToggledBuilder {
2743 fn as_ref(&self) -> &ChatEventVideoChatMuteNewParticipantsToggled { &self.inner }
2744}
2745
2746
2747
2748
2749
2750
2751
2752#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2754pub struct ChatEventVideoChatParticipantIsMutedToggled {
2755 #[doc(hidden)]
2756 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2757 td_name: String,
2758 #[doc(hidden)]
2759 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2760 extra: Option<String>,
2761 participant_id: MessageSender,
2763 is_muted: bool,
2765
2766}
2767
2768impl RObject for ChatEventVideoChatParticipantIsMutedToggled {
2769 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventVideoChatParticipantIsMutedToggled" }
2770 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2771 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2772}
2773
2774
2775impl TDChatEventAction for ChatEventVideoChatParticipantIsMutedToggled {}
2776
2777
2778
2779impl ChatEventVideoChatParticipantIsMutedToggled {
2780 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2781 pub fn builder() -> RTDChatEventVideoChatParticipantIsMutedToggledBuilder {
2782 let mut inner = ChatEventVideoChatParticipantIsMutedToggled::default();
2783 inner.td_name = "chatEventVideoChatParticipantIsMutedToggled".to_string();
2784 inner.extra = Some(Uuid::new_v4().to_string());
2785 RTDChatEventVideoChatParticipantIsMutedToggledBuilder { inner }
2786 }
2787
2788 pub fn participant_id(&self) -> &MessageSender { &self.participant_id }
2789
2790 pub fn is_muted(&self) -> bool { self.is_muted }
2791
2792}
2793
2794#[doc(hidden)]
2795pub struct RTDChatEventVideoChatParticipantIsMutedToggledBuilder {
2796 inner: ChatEventVideoChatParticipantIsMutedToggled
2797}
2798
2799impl RTDChatEventVideoChatParticipantIsMutedToggledBuilder {
2800 pub fn build(&self) -> ChatEventVideoChatParticipantIsMutedToggled { self.inner.clone() }
2801
2802
2803 pub fn participant_id<T: AsRef<MessageSender>>(&mut self, participant_id: T) -> &mut Self {
2804 self.inner.participant_id = participant_id.as_ref().clone();
2805 self
2806 }
2807
2808
2809 pub fn is_muted(&mut self, is_muted: bool) -> &mut Self {
2810 self.inner.is_muted = is_muted;
2811 self
2812 }
2813
2814}
2815
2816impl AsRef<ChatEventVideoChatParticipantIsMutedToggled> for ChatEventVideoChatParticipantIsMutedToggled {
2817 fn as_ref(&self) -> &ChatEventVideoChatParticipantIsMutedToggled { self }
2818}
2819
2820impl AsRef<ChatEventVideoChatParticipantIsMutedToggled> for RTDChatEventVideoChatParticipantIsMutedToggledBuilder {
2821 fn as_ref(&self) -> &ChatEventVideoChatParticipantIsMutedToggled { &self.inner }
2822}
2823
2824
2825
2826
2827
2828
2829
2830#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2832pub struct ChatEventVideoChatParticipantVolumeLevelChanged {
2833 #[doc(hidden)]
2834 #[serde(rename(serialize = "@type", deserialize = "@type"))]
2835 td_name: String,
2836 #[doc(hidden)]
2837 #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
2838 extra: Option<String>,
2839 participant_id: MessageSender,
2841 volume_level: i64,
2843
2844}
2845
2846impl RObject for ChatEventVideoChatParticipantVolumeLevelChanged {
2847 #[doc(hidden)] fn td_name(&self) -> &'static str { "chatEventVideoChatParticipantVolumeLevelChanged" }
2848 #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
2849 fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
2850}
2851
2852
2853impl TDChatEventAction for ChatEventVideoChatParticipantVolumeLevelChanged {}
2854
2855
2856
2857impl ChatEventVideoChatParticipantVolumeLevelChanged {
2858 pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
2859 pub fn builder() -> RTDChatEventVideoChatParticipantVolumeLevelChangedBuilder {
2860 let mut inner = ChatEventVideoChatParticipantVolumeLevelChanged::default();
2861 inner.td_name = "chatEventVideoChatParticipantVolumeLevelChanged".to_string();
2862 inner.extra = Some(Uuid::new_v4().to_string());
2863 RTDChatEventVideoChatParticipantVolumeLevelChangedBuilder { inner }
2864 }
2865
2866 pub fn participant_id(&self) -> &MessageSender { &self.participant_id }
2867
2868 pub fn volume_level(&self) -> i64 { self.volume_level }
2869
2870}
2871
2872#[doc(hidden)]
2873pub struct RTDChatEventVideoChatParticipantVolumeLevelChangedBuilder {
2874 inner: ChatEventVideoChatParticipantVolumeLevelChanged
2875}
2876
2877impl RTDChatEventVideoChatParticipantVolumeLevelChangedBuilder {
2878 pub fn build(&self) -> ChatEventVideoChatParticipantVolumeLevelChanged { self.inner.clone() }
2879
2880
2881 pub fn participant_id<T: AsRef<MessageSender>>(&mut self, participant_id: T) -> &mut Self {
2882 self.inner.participant_id = participant_id.as_ref().clone();
2883 self
2884 }
2885
2886
2887 pub fn volume_level(&mut self, volume_level: i64) -> &mut Self {
2888 self.inner.volume_level = volume_level;
2889 self
2890 }
2891
2892}
2893
2894impl AsRef<ChatEventVideoChatParticipantVolumeLevelChanged> for ChatEventVideoChatParticipantVolumeLevelChanged {
2895 fn as_ref(&self) -> &ChatEventVideoChatParticipantVolumeLevelChanged { self }
2896}
2897
2898impl AsRef<ChatEventVideoChatParticipantVolumeLevelChanged> for RTDChatEventVideoChatParticipantVolumeLevelChangedBuilder {
2899 fn as_ref(&self) -> &ChatEventVideoChatParticipantVolumeLevelChanged { &self.inner }
2900}
2901
2902
2903