1#![allow(clippy::large_enum_variant)]
4#![allow(clippy::should_implement_trait)]
5#![allow(clippy::unnecessary_to_owned)]
6
7pub mod client_api;
8pub mod commands;
9pub mod errors;
10pub mod events;
11pub mod responses;
12pub mod utils;
13
14use errors::*;
15use serde::{Deserialize, Serialize};
16use serde_aux::field_attributes::{
17 deserialize_number_from_string, deserialize_option_number_from_string,
18};
19use std::{
20 collections::{BTreeMap, HashMap},
21 sync::Arc,
22};
23use utils::CommandSyntax;
24
25pub type UtcTime = String;
26pub type JsonObject = serde_json::Value;
27
28#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
29#[cfg_attr(feature = "bon", derive(::bon::Builder))]
30#[cfg_attr(feature = "bon", builder(on(String, into)))]
31pub struct ACIReaction {
32 #[serde(rename = "chatInfo")]
33 pub chat_info: ChatInfo,
34
35 #[serde(rename = "chatReaction")]
36 pub chat_reaction: CIReaction,
37
38 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
39 #[cfg_attr(feature = "bon", builder(default))]
40 pub undocumented: BTreeMap<String, JsonObject>,
41}
42
43#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
44#[cfg_attr(feature = "bon", derive(::bon::Builder))]
45#[cfg_attr(feature = "bon", builder(on(String, into)))]
46pub struct AChat {
47 #[serde(rename = "chatInfo")]
48 pub chat_info: ChatInfo,
49
50 #[serde(rename = "chatItems")]
51 pub chat_items: Vec<ChatItem>,
52
53 #[serde(rename = "chatStats")]
54 pub chat_stats: ChatStats,
55
56 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
57 #[cfg_attr(feature = "bon", builder(default))]
58 pub undocumented: BTreeMap<String, JsonObject>,
59}
60
61#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
62#[cfg_attr(feature = "bon", derive(::bon::Builder))]
63#[cfg_attr(feature = "bon", builder(on(String, into)))]
64pub struct AChatItem {
65 #[serde(rename = "chatInfo")]
66 pub chat_info: ChatInfo,
67
68 #[serde(rename = "chatItem")]
69 pub chat_item: ChatItem,
70
71 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
72 #[cfg_attr(feature = "bon", builder(default))]
73 pub undocumented: BTreeMap<String, JsonObject>,
74}
75
76#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
77#[cfg_attr(feature = "bon", derive(::bon::Builder))]
78#[cfg_attr(feature = "bon", builder(on(String, into)))]
79pub struct AddressSettings {
80 #[serde(rename = "businessAddress")]
81 pub business_address: bool,
82
83 #[serde(rename = "autoAccept", skip_serializing_if = "Option::is_none")]
84 pub auto_accept: Option<AutoAccept>,
85
86 #[serde(rename = "autoReply", skip_serializing_if = "Option::is_none")]
87 pub auto_reply: Option<MsgContent>,
88
89 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
90 #[cfg_attr(feature = "bon", builder(default))]
91 pub undocumented: BTreeMap<String, JsonObject>,
92}
93
94#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
95#[cfg_attr(feature = "bon", derive(::bon::Builder))]
96#[cfg_attr(feature = "bon", builder(on(String, into)))]
97pub struct AutoAccept {
98 #[serde(rename = "acceptIncognito")]
99 pub accept_incognito: bool,
100
101 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
102 #[cfg_attr(feature = "bon", builder(default))]
103 pub undocumented: BTreeMap<String, JsonObject>,
104}
105
106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
107#[cfg_attr(feature = "bon", derive(::bon::Builder))]
108#[cfg_attr(feature = "bon", builder(on(String, into)))]
109pub struct BlockingInfo {
110 #[serde(rename = "reason")]
111 pub reason: BlockingReason,
112
113 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
114 #[cfg_attr(feature = "bon", builder(default))]
115 pub undocumented: BTreeMap<String, JsonObject>,
116}
117
118#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
119#[non_exhaustive]
120pub enum BlockingReason {
121 #[default]
122 #[serde(rename = "spam")]
123 Spam,
124 #[serde(rename = "content")]
125 Content,
126}
127
128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
129#[cfg_attr(feature = "bon", derive(::bon::Builder))]
130#[cfg_attr(feature = "bon", builder(on(String, into)))]
131pub struct BusinessChatInfo {
132 #[serde(rename = "chatType")]
133 pub chat_type: BusinessChatType,
134
135 #[serde(rename = "businessId")]
136 pub business_id: String,
137
138 #[serde(rename = "customerId")]
139 pub customer_id: String,
140
141 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
142 #[cfg_attr(feature = "bon", builder(default))]
143 pub undocumented: BTreeMap<String, JsonObject>,
144}
145
146#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
147#[non_exhaustive]
148pub enum BusinessChatType {
149 #[default]
150 #[serde(rename = "business")]
151 Business,
152 #[serde(rename = "customer")]
153 Customer,
154}
155
156#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
157#[non_exhaustive]
158pub enum CICallStatus {
159 #[default]
160 #[serde(rename = "pending")]
161 Pending,
162 #[serde(rename = "missed")]
163 Missed,
164 #[serde(rename = "rejected")]
165 Rejected,
166 #[serde(rename = "accepted")]
167 Accepted,
168 #[serde(rename = "negotiated")]
169 Negotiated,
170 #[serde(rename = "progress")]
171 Progress,
172 #[serde(rename = "ended")]
173 Ended,
174 #[serde(rename = "error")]
175 Error,
176}
177
178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
179#[serde(tag = "type")]
180#[non_exhaustive]
181pub enum CIContent {
182 #[serde(rename = "sndMsgContent")]
183 SndMsgContent {
184 #[serde(rename = "msgContent")]
185 msg_content: MsgContent,
186
187 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
188 undocumented: BTreeMap<String, JsonObject>,
189 },
190 #[serde(rename = "rcvMsgContent")]
191 RcvMsgContent {
192 #[serde(rename = "msgContent")]
193 msg_content: MsgContent,
194
195 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
196 undocumented: BTreeMap<String, JsonObject>,
197 },
198 #[serde(rename = "sndDeleted")]
199 SndDeleted {
200 #[serde(rename = "deleteMode")]
201 delete_mode: CIDeleteMode,
202
203 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
204 undocumented: BTreeMap<String, JsonObject>,
205 },
206 #[serde(rename = "rcvDeleted")]
207 RcvDeleted {
208 #[serde(rename = "deleteMode")]
209 delete_mode: CIDeleteMode,
210
211 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
212 undocumented: BTreeMap<String, JsonObject>,
213 },
214 #[serde(rename = "sndCall")]
215 SndCall {
216 #[serde(rename = "status")]
217 status: CICallStatus,
218
219 #[serde(
220 rename = "duration",
221 deserialize_with = "deserialize_number_from_string"
222 )]
223 duration: i32,
224
225 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
226 undocumented: BTreeMap<String, JsonObject>,
227 },
228 #[serde(rename = "rcvCall")]
229 RcvCall {
230 #[serde(rename = "status")]
231 status: CICallStatus,
232
233 #[serde(
234 rename = "duration",
235 deserialize_with = "deserialize_number_from_string"
236 )]
237 duration: i32,
238
239 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
240 undocumented: BTreeMap<String, JsonObject>,
241 },
242 #[serde(rename = "rcvIntegrityError")]
243 RcvIntegrityError {
244 #[serde(rename = "msgError")]
245 msg_error: MsgErrorType,
246
247 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
248 undocumented: BTreeMap<String, JsonObject>,
249 },
250 #[serde(rename = "rcvDecryptionError")]
251 RcvDecryptionError {
252 #[serde(rename = "msgDecryptError")]
253 msg_decrypt_error: MsgDecryptError,
254
255 #[serde(
256 rename = "msgCount",
257 deserialize_with = "deserialize_number_from_string"
258 )]
259 msg_count: u32,
260
261 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
262 undocumented: BTreeMap<String, JsonObject>,
263 },
264 #[serde(rename = "rcvGroupInvitation")]
265 RcvGroupInvitation {
266 #[serde(rename = "groupInvitation")]
267 group_invitation: CIGroupInvitation,
268
269 #[serde(rename = "memberRole")]
270 member_role: GroupMemberRole,
271
272 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
273 undocumented: BTreeMap<String, JsonObject>,
274 },
275 #[serde(rename = "sndGroupInvitation")]
276 SndGroupInvitation {
277 #[serde(rename = "groupInvitation")]
278 group_invitation: CIGroupInvitation,
279
280 #[serde(rename = "memberRole")]
281 member_role: GroupMemberRole,
282
283 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
284 undocumented: BTreeMap<String, JsonObject>,
285 },
286 #[serde(rename = "rcvDirectEvent")]
287 RcvDirectEvent {
288 #[serde(rename = "rcvDirectEvent")]
289 rcv_direct_event: RcvDirectEvent,
290
291 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
292 undocumented: BTreeMap<String, JsonObject>,
293 },
294 #[serde(rename = "rcvGroupEvent")]
295 RcvGroupEvent {
296 #[serde(rename = "rcvGroupEvent")]
297 rcv_group_event: RcvGroupEvent,
298
299 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
300 undocumented: BTreeMap<String, JsonObject>,
301 },
302 #[serde(rename = "sndGroupEvent")]
303 SndGroupEvent {
304 #[serde(rename = "sndGroupEvent")]
305 snd_group_event: SndGroupEvent,
306
307 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
308 undocumented: BTreeMap<String, JsonObject>,
309 },
310 #[serde(rename = "rcvConnEvent")]
311 RcvConnEvent {
312 #[serde(rename = "rcvConnEvent")]
313 rcv_conn_event: RcvConnEvent,
314
315 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
316 undocumented: BTreeMap<String, JsonObject>,
317 },
318 #[serde(rename = "sndConnEvent")]
319 SndConnEvent {
320 #[serde(rename = "sndConnEvent")]
321 snd_conn_event: SndConnEvent,
322
323 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
324 undocumented: BTreeMap<String, JsonObject>,
325 },
326 #[serde(rename = "rcvChatFeature")]
327 RcvChatFeature {
328 #[serde(rename = "feature")]
329 feature: ChatFeature,
330
331 #[serde(rename = "enabled")]
332 enabled: PrefEnabled,
333
334 #[serde(
335 rename = "param",
336 skip_serializing_if = "Option::is_none",
337 deserialize_with = "deserialize_option_number_from_string",
338 default
339 )]
340 param: Option<i32>,
341
342 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
343 undocumented: BTreeMap<String, JsonObject>,
344 },
345 #[serde(rename = "sndChatFeature")]
346 SndChatFeature {
347 #[serde(rename = "feature")]
348 feature: ChatFeature,
349
350 #[serde(rename = "enabled")]
351 enabled: PrefEnabled,
352
353 #[serde(
354 rename = "param",
355 skip_serializing_if = "Option::is_none",
356 deserialize_with = "deserialize_option_number_from_string",
357 default
358 )]
359 param: Option<i32>,
360
361 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
362 undocumented: BTreeMap<String, JsonObject>,
363 },
364 #[serde(rename = "rcvChatPreference")]
365 RcvChatPreference {
366 #[serde(rename = "feature")]
367 feature: ChatFeature,
368
369 #[serde(rename = "allowed")]
370 allowed: FeatureAllowed,
371
372 #[serde(
373 rename = "param",
374 skip_serializing_if = "Option::is_none",
375 deserialize_with = "deserialize_option_number_from_string",
376 default
377 )]
378 param: Option<i32>,
379
380 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
381 undocumented: BTreeMap<String, JsonObject>,
382 },
383 #[serde(rename = "sndChatPreference")]
384 SndChatPreference {
385 #[serde(rename = "feature")]
386 feature: ChatFeature,
387
388 #[serde(rename = "allowed")]
389 allowed: FeatureAllowed,
390
391 #[serde(
392 rename = "param",
393 skip_serializing_if = "Option::is_none",
394 deserialize_with = "deserialize_option_number_from_string",
395 default
396 )]
397 param: Option<i32>,
398
399 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
400 undocumented: BTreeMap<String, JsonObject>,
401 },
402 #[serde(rename = "rcvGroupFeature")]
403 RcvGroupFeature {
404 #[serde(rename = "groupFeature")]
405 group_feature: GroupFeature,
406
407 #[serde(rename = "preference")]
408 preference: GroupPreference,
409
410 #[serde(
411 rename = "param",
412 skip_serializing_if = "Option::is_none",
413 deserialize_with = "deserialize_option_number_from_string",
414 default
415 )]
416 param: Option<i32>,
417
418 #[serde(rename = "memberRole_", skip_serializing_if = "Option::is_none")]
419 member_role: Option<GroupMemberRole>,
420
421 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
422 undocumented: BTreeMap<String, JsonObject>,
423 },
424 #[serde(rename = "sndGroupFeature")]
425 SndGroupFeature {
426 #[serde(rename = "groupFeature")]
427 group_feature: GroupFeature,
428
429 #[serde(rename = "preference")]
430 preference: GroupPreference,
431
432 #[serde(
433 rename = "param",
434 skip_serializing_if = "Option::is_none",
435 deserialize_with = "deserialize_option_number_from_string",
436 default
437 )]
438 param: Option<i32>,
439
440 #[serde(rename = "memberRole_", skip_serializing_if = "Option::is_none")]
441 member_role: Option<GroupMemberRole>,
442
443 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
444 undocumented: BTreeMap<String, JsonObject>,
445 },
446 #[serde(rename = "rcvChatFeatureRejected")]
447 RcvChatFeatureRejected {
448 #[serde(rename = "feature")]
449 feature: ChatFeature,
450
451 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
452 undocumented: BTreeMap<String, JsonObject>,
453 },
454 #[serde(rename = "rcvGroupFeatureRejected")]
455 RcvGroupFeatureRejected {
456 #[serde(rename = "groupFeature")]
457 group_feature: GroupFeature,
458
459 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
460 undocumented: BTreeMap<String, JsonObject>,
461 },
462 #[serde(rename = "sndModerated")]
463 SndModerated,
464 #[serde(rename = "rcvModerated")]
465 RcvModerated,
466 #[serde(rename = "rcvBlocked")]
467 RcvBlocked,
468 #[serde(rename = "sndDirectE2EEInfo")]
469 SndDirectE2EeInfo {
470 #[serde(rename = "e2eeInfo")]
471 e_2_ee_info: E2EInfo,
472
473 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
474 undocumented: BTreeMap<String, JsonObject>,
475 },
476 #[serde(rename = "rcvDirectE2EEInfo")]
477 RcvDirectE2EeInfo {
478 #[serde(rename = "e2eeInfo")]
479 e_2_ee_info: E2EInfo,
480
481 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
482 undocumented: BTreeMap<String, JsonObject>,
483 },
484 #[serde(rename = "sndGroupE2EEInfo")]
485 SndGroupE2EeInfo {
486 #[serde(rename = "e2eeInfo")]
487 e_2_ee_info: E2EInfo,
488
489 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
490 undocumented: BTreeMap<String, JsonObject>,
491 },
492 #[serde(rename = "rcvGroupE2EEInfo")]
493 RcvGroupE2EeInfo {
494 #[serde(rename = "e2eeInfo")]
495 e_2_ee_info: E2EInfo,
496
497 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
498 undocumented: BTreeMap<String, JsonObject>,
499 },
500 #[serde(rename = "chatBanner")]
501 ChatBanner,
502 #[serde(untagged)]
503 Undocumented(BTreeMap<String, JsonObject>),
504}
505
506#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
507#[non_exhaustive]
508pub enum CIDeleteMode {
509 #[default]
510 #[serde(rename = "broadcast")]
511 Broadcast,
512 #[serde(rename = "internal")]
513 Internal,
514 #[serde(rename = "internalMark")]
515 InternalMark,
516}
517
518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
519#[serde(tag = "type")]
520#[non_exhaustive]
521pub enum CIDeleted {
522 #[serde(rename = "deleted")]
523 Deleted {
524 #[serde(rename = "deletedTs", skip_serializing_if = "Option::is_none")]
525 deleted_ts: Option<UtcTime>,
526
527 #[serde(rename = "chatType")]
528 chat_type: ChatType,
529
530 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
531 undocumented: BTreeMap<String, JsonObject>,
532 },
533 #[serde(rename = "blocked")]
534 Blocked {
535 #[serde(rename = "deletedTs", skip_serializing_if = "Option::is_none")]
536 deleted_ts: Option<UtcTime>,
537
538 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
539 undocumented: BTreeMap<String, JsonObject>,
540 },
541 #[serde(rename = "blockedByAdmin")]
542 BlockedByAdmin {
543 #[serde(rename = "deletedTs", skip_serializing_if = "Option::is_none")]
544 deleted_ts: Option<UtcTime>,
545
546 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
547 undocumented: BTreeMap<String, JsonObject>,
548 },
549 #[serde(rename = "moderated")]
550 Moderated {
551 #[serde(rename = "deletedTs", skip_serializing_if = "Option::is_none")]
552 deleted_ts: Option<UtcTime>,
553
554 #[serde(rename = "byGroupMember")]
555 by_group_member: GroupMember,
556
557 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
558 undocumented: BTreeMap<String, JsonObject>,
559 },
560 #[serde(untagged)]
561 Undocumented(BTreeMap<String, JsonObject>),
562}
563
564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
565#[serde(tag = "type")]
566#[non_exhaustive]
567pub enum CIDirection {
568 #[serde(rename = "directSnd")]
569 DirectSnd,
570 #[serde(rename = "directRcv")]
571 DirectRcv,
572 #[serde(rename = "groupSnd")]
573 GroupSnd,
574 #[serde(rename = "groupRcv")]
575 GroupRcv {
576 #[serde(rename = "groupMember")]
577 group_member: GroupMember,
578
579 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
580 undocumented: BTreeMap<String, JsonObject>,
581 },
582 #[serde(rename = "localSnd")]
583 LocalSnd,
584 #[serde(rename = "localRcv")]
585 LocalRcv,
586 #[serde(untagged)]
587 Undocumented(BTreeMap<String, JsonObject>),
588}
589
590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
591#[cfg_attr(feature = "bon", derive(::bon::Builder))]
592#[cfg_attr(feature = "bon", builder(on(String, into)))]
593pub struct CIFile {
594 #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
595 pub file_id: i64,
596
597 #[serde(rename = "fileName")]
598 pub file_name: String,
599
600 #[serde(
601 rename = "fileSize",
602 deserialize_with = "deserialize_number_from_string"
603 )]
604 pub file_size: i64,
605
606 #[serde(rename = "fileSource", skip_serializing_if = "Option::is_none")]
607 pub file_source: Option<CryptoFile>,
608
609 #[serde(rename = "fileStatus")]
610 pub file_status: CIFileStatus,
611
612 #[serde(rename = "fileProtocol")]
613 pub file_protocol: FileProtocol,
614
615 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
616 #[cfg_attr(feature = "bon", builder(default))]
617 pub undocumented: BTreeMap<String, JsonObject>,
618}
619
620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
621#[serde(tag = "type")]
622#[non_exhaustive]
623pub enum CIFileStatus {
624 #[serde(rename = "sndStored")]
625 SndStored,
626 #[serde(rename = "sndTransfer")]
627 SndTransfer {
628 #[serde(
629 rename = "sndProgress",
630 deserialize_with = "deserialize_number_from_string"
631 )]
632 snd_progress: i64,
633
634 #[serde(
635 rename = "sndTotal",
636 deserialize_with = "deserialize_number_from_string"
637 )]
638 snd_total: i64,
639
640 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
641 undocumented: BTreeMap<String, JsonObject>,
642 },
643 #[serde(rename = "sndCancelled")]
644 SndCancelled,
645 #[serde(rename = "sndComplete")]
646 SndComplete,
647 #[serde(rename = "sndError")]
648 SndError {
649 #[serde(rename = "sndFileError")]
650 snd_file_error: FileError,
651
652 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
653 undocumented: BTreeMap<String, JsonObject>,
654 },
655 #[serde(rename = "sndWarning")]
656 SndWarning {
657 #[serde(rename = "sndFileError")]
658 snd_file_error: FileError,
659
660 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
661 undocumented: BTreeMap<String, JsonObject>,
662 },
663 #[serde(rename = "rcvInvitation")]
664 RcvInvitation,
665 #[serde(rename = "rcvAccepted")]
666 RcvAccepted,
667 #[serde(rename = "rcvTransfer")]
668 RcvTransfer {
669 #[serde(
670 rename = "rcvProgress",
671 deserialize_with = "deserialize_number_from_string"
672 )]
673 rcv_progress: i64,
674
675 #[serde(
676 rename = "rcvTotal",
677 deserialize_with = "deserialize_number_from_string"
678 )]
679 rcv_total: i64,
680
681 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
682 undocumented: BTreeMap<String, JsonObject>,
683 },
684 #[serde(rename = "rcvAborted")]
685 RcvAborted,
686 #[serde(rename = "rcvComplete")]
687 RcvComplete,
688 #[serde(rename = "rcvCancelled")]
689 RcvCancelled,
690 #[serde(rename = "rcvError")]
691 RcvError {
692 #[serde(rename = "rcvFileError")]
693 rcv_file_error: FileError,
694
695 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
696 undocumented: BTreeMap<String, JsonObject>,
697 },
698 #[serde(rename = "rcvWarning")]
699 RcvWarning {
700 #[serde(rename = "rcvFileError")]
701 rcv_file_error: FileError,
702
703 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
704 undocumented: BTreeMap<String, JsonObject>,
705 },
706 #[serde(rename = "invalid")]
707 Invalid {
708 #[serde(rename = "text")]
709 text: String,
710
711 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
712 undocumented: BTreeMap<String, JsonObject>,
713 },
714 #[serde(untagged)]
715 Undocumented(BTreeMap<String, JsonObject>),
716}
717
718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
719#[serde(tag = "type")]
720#[non_exhaustive]
721pub enum CIForwardedFrom {
722 #[serde(rename = "unknown")]
723 Unknown,
724 #[serde(rename = "contact")]
725 Contact {
726 #[serde(rename = "chatName")]
727 chat_name: String,
728
729 #[serde(rename = "msgDir")]
730 msg_dir: MsgDirection,
731
732 #[serde(
733 rename = "contactId",
734 skip_serializing_if = "Option::is_none",
735 deserialize_with = "deserialize_option_number_from_string",
736 default
737 )]
738 contact_id: Option<i64>,
739
740 #[serde(
741 rename = "chatItemId",
742 skip_serializing_if = "Option::is_none",
743 deserialize_with = "deserialize_option_number_from_string",
744 default
745 )]
746 chat_item_id: Option<i64>,
747
748 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
749 undocumented: BTreeMap<String, JsonObject>,
750 },
751 #[serde(rename = "group")]
752 Group {
753 #[serde(rename = "chatName")]
754 chat_name: String,
755
756 #[serde(rename = "msgDir")]
757 msg_dir: MsgDirection,
758
759 #[serde(
760 rename = "groupId",
761 skip_serializing_if = "Option::is_none",
762 deserialize_with = "deserialize_option_number_from_string",
763 default
764 )]
765 group_id: Option<i64>,
766
767 #[serde(
768 rename = "chatItemId",
769 skip_serializing_if = "Option::is_none",
770 deserialize_with = "deserialize_option_number_from_string",
771 default
772 )]
773 chat_item_id: Option<i64>,
774
775 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
776 undocumented: BTreeMap<String, JsonObject>,
777 },
778 #[serde(untagged)]
779 Undocumented(BTreeMap<String, JsonObject>),
780}
781
782#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
783#[cfg_attr(feature = "bon", derive(::bon::Builder))]
784#[cfg_attr(feature = "bon", builder(on(String, into)))]
785pub struct CIGroupInvitation {
786 #[serde(
787 rename = "groupId",
788 deserialize_with = "deserialize_number_from_string"
789 )]
790 pub group_id: i64,
791
792 #[serde(
793 rename = "groupMemberId",
794 deserialize_with = "deserialize_number_from_string"
795 )]
796 pub group_member_id: i64,
797
798 #[serde(rename = "localDisplayName")]
799 pub local_display_name: String,
800
801 #[serde(rename = "groupProfile")]
802 pub group_profile: GroupProfile,
803
804 #[serde(rename = "status")]
805 pub status: CIGroupInvitationStatus,
806
807 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
808 #[cfg_attr(feature = "bon", builder(default))]
809 pub undocumented: BTreeMap<String, JsonObject>,
810}
811
812#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
813#[non_exhaustive]
814pub enum CIGroupInvitationStatus {
815 #[default]
816 #[serde(rename = "pending")]
817 Pending,
818 #[serde(rename = "accepted")]
819 Accepted,
820 #[serde(rename = "rejected")]
821 Rejected,
822 #[serde(rename = "expired")]
823 Expired,
824}
825
826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
827#[cfg_attr(feature = "bon", derive(::bon::Builder))]
828#[cfg_attr(feature = "bon", builder(on(String, into)))]
829pub struct CIMention {
830 #[serde(rename = "memberId")]
831 pub member_id: String,
832
833 #[serde(rename = "memberRef", skip_serializing_if = "Option::is_none")]
834 pub member_ref: Option<CIMentionMember>,
835
836 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
837 #[cfg_attr(feature = "bon", builder(default))]
838 pub undocumented: BTreeMap<String, JsonObject>,
839}
840
841#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
842#[cfg_attr(feature = "bon", derive(::bon::Builder))]
843#[cfg_attr(feature = "bon", builder(on(String, into)))]
844pub struct CIMentionMember {
845 #[serde(
846 rename = "groupMemberId",
847 deserialize_with = "deserialize_number_from_string"
848 )]
849 pub group_member_id: i64,
850
851 #[serde(rename = "displayName")]
852 pub display_name: String,
853
854 #[serde(rename = "localAlias", skip_serializing_if = "Option::is_none")]
855 pub local_alias: Option<String>,
856
857 #[serde(rename = "memberRole")]
858 pub member_role: GroupMemberRole,
859
860 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
861 #[cfg_attr(feature = "bon", builder(default))]
862 pub undocumented: BTreeMap<String, JsonObject>,
863}
864
865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
866#[cfg_attr(feature = "bon", derive(::bon::Builder))]
867#[cfg_attr(feature = "bon", builder(on(String, into)))]
868pub struct CIMeta {
869 #[serde(rename = "itemId", deserialize_with = "deserialize_number_from_string")]
870 pub item_id: i64,
871
872 #[serde(rename = "itemTs")]
873 pub item_ts: UtcTime,
874
875 #[serde(rename = "itemText")]
876 pub item_text: String,
877
878 #[serde(rename = "itemStatus")]
879 pub item_status: CIStatus,
880
881 #[serde(rename = "sentViaProxy", skip_serializing_if = "Option::is_none")]
882 pub sent_via_proxy: Option<bool>,
883
884 #[serde(rename = "itemSharedMsgId", skip_serializing_if = "Option::is_none")]
885 pub item_shared_msg_id: Option<String>,
886
887 #[serde(rename = "itemForwarded", skip_serializing_if = "Option::is_none")]
888 pub item_forwarded: Option<CIForwardedFrom>,
889
890 #[serde(rename = "itemDeleted", skip_serializing_if = "Option::is_none")]
891 pub item_deleted: Option<CIDeleted>,
892
893 #[serde(rename = "itemEdited")]
894 pub item_edited: bool,
895
896 #[serde(rename = "itemTimed", skip_serializing_if = "Option::is_none")]
897 pub item_timed: Option<CITimed>,
898
899 #[serde(rename = "itemLive", skip_serializing_if = "Option::is_none")]
900 pub item_live: Option<bool>,
901
902 #[serde(rename = "userMention")]
903 pub user_mention: bool,
904
905 #[serde(rename = "deletable")]
906 pub deletable: bool,
907
908 #[serde(rename = "editable")]
909 pub editable: bool,
910
911 #[serde(
912 rename = "forwardedByMember",
913 skip_serializing_if = "Option::is_none",
914 deserialize_with = "deserialize_option_number_from_string",
915 default
916 )]
917 pub forwarded_by_member: Option<i64>,
918
919 #[serde(rename = "showGroupAsSender")]
920 pub show_group_as_sender: bool,
921
922 #[serde(rename = "createdAt")]
923 pub created_at: UtcTime,
924
925 #[serde(rename = "updatedAt")]
926 pub updated_at: UtcTime,
927
928 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
929 #[cfg_attr(feature = "bon", builder(default))]
930 pub undocumented: BTreeMap<String, JsonObject>,
931}
932
933#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
934#[cfg_attr(feature = "bon", derive(::bon::Builder))]
935#[cfg_attr(feature = "bon", builder(on(String, into)))]
936pub struct CIQuote {
937 #[serde(rename = "chatDir", skip_serializing_if = "Option::is_none")]
938 pub chat_dir: Option<CIDirection>,
939
940 #[serde(
941 rename = "itemId",
942 skip_serializing_if = "Option::is_none",
943 deserialize_with = "deserialize_option_number_from_string",
944 default
945 )]
946 pub item_id: Option<i64>,
947
948 #[serde(rename = "sharedMsgId", skip_serializing_if = "Option::is_none")]
949 pub shared_msg_id: Option<String>,
950
951 #[serde(rename = "sentAt")]
952 pub sent_at: UtcTime,
953
954 #[serde(rename = "content")]
955 pub content: MsgContent,
956
957 #[serde(rename = "formattedText", skip_serializing_if = "Option::is_none")]
958 pub formatted_text: Option<Vec<FormattedText>>,
959
960 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
961 #[cfg_attr(feature = "bon", builder(default))]
962 pub undocumented: BTreeMap<String, JsonObject>,
963}
964
965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
966#[cfg_attr(feature = "bon", derive(::bon::Builder))]
967#[cfg_attr(feature = "bon", builder(on(String, into)))]
968pub struct CIReaction {
969 #[serde(rename = "chatDir")]
970 pub chat_dir: CIDirection,
971
972 #[serde(rename = "chatItem")]
973 pub chat_item: ChatItem,
974
975 #[serde(rename = "sentAt")]
976 pub sent_at: UtcTime,
977
978 #[serde(rename = "reaction")]
979 pub reaction: MsgReaction,
980
981 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
982 #[cfg_attr(feature = "bon", builder(default))]
983 pub undocumented: BTreeMap<String, JsonObject>,
984}
985
986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
987#[cfg_attr(feature = "bon", derive(::bon::Builder))]
988#[cfg_attr(feature = "bon", builder(on(String, into)))]
989pub struct CIReactionCount {
990 #[serde(rename = "reaction")]
991 pub reaction: MsgReaction,
992
993 #[serde(rename = "userReacted")]
994 pub user_reacted: bool,
995
996 #[serde(
997 rename = "totalReacted",
998 deserialize_with = "deserialize_number_from_string"
999 )]
1000 pub total_reacted: i32,
1001
1002 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1003 #[cfg_attr(feature = "bon", builder(default))]
1004 pub undocumented: BTreeMap<String, JsonObject>,
1005}
1006
1007#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1008#[serde(tag = "type")]
1009#[non_exhaustive]
1010pub enum CIStatus {
1011 #[serde(rename = "sndNew")]
1012 SndNew,
1013 #[serde(rename = "sndSent")]
1014 SndSent {
1015 #[serde(rename = "sndProgress")]
1016 snd_progress: SndCIStatusProgress,
1017
1018 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1019 undocumented: BTreeMap<String, JsonObject>,
1020 },
1021 #[serde(rename = "sndRcvd")]
1022 SndRcvd {
1023 #[serde(rename = "msgRcptStatus")]
1024 msg_rcpt_status: MsgReceiptStatus,
1025
1026 #[serde(rename = "sndProgress")]
1027 snd_progress: SndCIStatusProgress,
1028
1029 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1030 undocumented: BTreeMap<String, JsonObject>,
1031 },
1032 #[serde(rename = "sndErrorAuth")]
1033 SndErrorAuth,
1034 #[serde(rename = "sndError")]
1035 SndError {
1036 #[serde(rename = "agentError")]
1037 agent_error: SndError,
1038
1039 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1040 undocumented: BTreeMap<String, JsonObject>,
1041 },
1042 #[serde(rename = "sndWarning")]
1043 SndWarning {
1044 #[serde(rename = "agentError")]
1045 agent_error: SndError,
1046
1047 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1048 undocumented: BTreeMap<String, JsonObject>,
1049 },
1050 #[serde(rename = "rcvNew")]
1051 RcvNew,
1052 #[serde(rename = "rcvRead")]
1053 RcvRead,
1054 #[serde(rename = "invalid")]
1055 Invalid {
1056 #[serde(rename = "text")]
1057 text: String,
1058
1059 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1060 undocumented: BTreeMap<String, JsonObject>,
1061 },
1062 #[serde(untagged)]
1063 Undocumented(BTreeMap<String, JsonObject>),
1064}
1065
1066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1067#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1068#[cfg_attr(feature = "bon", builder(on(String, into)))]
1069pub struct CITimed {
1070 #[serde(rename = "ttl", deserialize_with = "deserialize_number_from_string")]
1071 pub ttl: i32,
1072
1073 #[serde(rename = "deleteAt", skip_serializing_if = "Option::is_none")]
1074 pub delete_at: Option<UtcTime>,
1075
1076 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1077 #[cfg_attr(feature = "bon", builder(default))]
1078 pub undocumented: BTreeMap<String, JsonObject>,
1079}
1080
1081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1082#[serde(tag = "type")]
1083#[non_exhaustive]
1084pub enum ChatBotCommand {
1085 #[serde(rename = "command")]
1086 Command {
1087 #[serde(rename = "keyword")]
1088 keyword: String,
1089
1090 #[serde(rename = "label")]
1091 label: String,
1092
1093 #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
1094 params: Option<String>,
1095
1096 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1097 undocumented: BTreeMap<String, JsonObject>,
1098 },
1099 #[serde(rename = "menu")]
1100 Menu {
1101 #[serde(rename = "label")]
1102 label: String,
1103
1104 #[serde(rename = "commands")]
1105 commands: Vec<ChatBotCommand>,
1106
1107 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1108 undocumented: BTreeMap<String, JsonObject>,
1109 },
1110 #[serde(untagged)]
1111 Undocumented(BTreeMap<String, JsonObject>),
1112}
1113
1114#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1120#[serde(tag = "type")]
1121#[non_exhaustive]
1122pub enum ChatDeleteMode {
1123 #[serde(rename = "full")]
1124 Full {
1125 #[serde(rename = "notify")]
1126 notify: bool,
1127
1128 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1129 undocumented: BTreeMap<String, JsonObject>,
1130 },
1131 #[serde(rename = "entity")]
1132 Entity {
1133 #[serde(rename = "notify")]
1134 notify: bool,
1135
1136 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1137 undocumented: BTreeMap<String, JsonObject>,
1138 },
1139 #[serde(rename = "messages")]
1140 Messages,
1141 #[serde(untagged)]
1142 Undocumented(BTreeMap<String, JsonObject>),
1143}
1144
1145impl CommandSyntax for ChatDeleteMode {
1146 fn interpret(&self) -> String {
1147 let mut buf = String::with_capacity(64);
1148 match self {
1149 Self::Full { notify, .. } => {
1150 buf.push_str("full");
1151 if !notify {
1152 buf.push_str(" notify=off");
1153 }
1154 }
1155 Self::Entity { notify, .. } => {
1156 buf.push_str("entity");
1157 if !notify {
1158 buf.push_str(" notify=off");
1159 }
1160 }
1161 Self::Messages | Self::Undocumented(_) => {}
1162 }
1163 buf
1164 }
1165}
1166
1167#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1168#[non_exhaustive]
1169pub enum ChatFeature {
1170 #[default]
1171 #[serde(rename = "timedMessages")]
1172 TimedMessages,
1173 #[serde(rename = "fullDelete")]
1174 FullDelete,
1175 #[serde(rename = "reactions")]
1176 Reactions,
1177 #[serde(rename = "voice")]
1178 Voice,
1179 #[serde(rename = "files")]
1180 Files,
1181 #[serde(rename = "calls")]
1182 Calls,
1183 #[serde(rename = "sessions")]
1184 Sessions,
1185}
1186
1187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1188#[serde(tag = "type")]
1189#[non_exhaustive]
1190pub enum ChatInfo {
1191 #[serde(rename = "direct")]
1192 Direct {
1193 #[serde(rename = "contact")]
1194 contact: Contact,
1195
1196 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1197 undocumented: BTreeMap<String, JsonObject>,
1198 },
1199 #[serde(rename = "group")]
1200 Group {
1201 #[serde(rename = "groupInfo")]
1202 group_info: GroupInfo,
1203
1204 #[serde(rename = "groupChatScope", skip_serializing_if = "Option::is_none")]
1205 group_chat_scope: Option<GroupChatScopeInfo>,
1206
1207 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1208 undocumented: BTreeMap<String, JsonObject>,
1209 },
1210 #[serde(rename = "local")]
1211 Local {
1212 #[serde(rename = "noteFolder")]
1213 note_folder: NoteFolder,
1214
1215 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1216 undocumented: BTreeMap<String, JsonObject>,
1217 },
1218 #[serde(rename = "contactRequest")]
1219 ContactRequest {
1220 #[serde(rename = "contactRequest")]
1221 contact_request: UserContactRequest,
1222
1223 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1224 undocumented: BTreeMap<String, JsonObject>,
1225 },
1226 #[serde(rename = "contactConnection")]
1227 ContactConnection {
1228 #[serde(rename = "contactConnection")]
1229 contact_connection: PendingContactConnection,
1230
1231 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1232 undocumented: BTreeMap<String, JsonObject>,
1233 },
1234 #[serde(untagged)]
1235 Undocumented(BTreeMap<String, JsonObject>),
1236}
1237
1238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1239#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1240#[cfg_attr(feature = "bon", builder(on(String, into)))]
1241pub struct ChatItem {
1242 #[serde(rename = "chatDir")]
1243 pub chat_dir: CIDirection,
1244
1245 #[serde(rename = "meta")]
1246 pub meta: CIMeta,
1247
1248 #[serde(rename = "content")]
1249 pub content: CIContent,
1250
1251 #[serde(rename = "mentions")]
1252 pub mentions: HashMap<String, CIMention>,
1253
1254 #[serde(rename = "formattedText", skip_serializing_if = "Option::is_none")]
1255 pub formatted_text: Option<Vec<FormattedText>>,
1256
1257 #[serde(rename = "quotedItem", skip_serializing_if = "Option::is_none")]
1258 pub quoted_item: Option<CIQuote>,
1259
1260 #[serde(rename = "reactions")]
1261 pub reactions: Vec<CIReactionCount>,
1262
1263 #[serde(rename = "file", skip_serializing_if = "Option::is_none")]
1264 pub file: Option<CIFile>,
1265
1266 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1267 #[cfg_attr(feature = "bon", builder(default))]
1268 pub undocumented: BTreeMap<String, JsonObject>,
1269}
1270
1271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1273#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1274#[cfg_attr(feature = "bon", builder(on(String, into)))]
1275pub struct ChatItemDeletion {
1276 #[serde(rename = "deletedChatItem")]
1277 pub deleted_chat_item: AChatItem,
1278
1279 #[serde(rename = "toChatItem", skip_serializing_if = "Option::is_none")]
1280 pub to_chat_item: Option<AChatItem>,
1281
1282 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1283 #[cfg_attr(feature = "bon", builder(default))]
1284 pub undocumented: BTreeMap<String, JsonObject>,
1285}
1286
1287#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1288#[non_exhaustive]
1289pub enum ChatPeerType {
1290 #[default]
1291 #[serde(rename = "human")]
1292 Human,
1293 #[serde(rename = "bot")]
1294 Bot,
1295}
1296
1297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1305#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1306#[cfg_attr(feature = "bon", builder(on(String, into)))]
1307pub struct ChatRef {
1308 #[serde(rename = "chatType")]
1309 pub chat_type: ChatType,
1310
1311 #[serde(rename = "chatId", deserialize_with = "deserialize_number_from_string")]
1312 pub chat_id: i64,
1313
1314 #[serde(rename = "chatScope", skip_serializing_if = "Option::is_none")]
1315 pub chat_scope: Option<GroupChatScope>,
1316
1317 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1318 #[cfg_attr(feature = "bon", builder(default))]
1319 pub undocumented: BTreeMap<String, JsonObject>,
1320}
1321
1322impl CommandSyntax for ChatRef {
1323 fn interpret(&self) -> String {
1324 let mut buf = String::with_capacity(256);
1325 buf.push_str(&self.chat_type.interpret());
1326 buf.push_str(&self.chat_id.to_string());
1327 if let Some(chat_scope) = &self.chat_scope {
1328 buf.push_str(&chat_scope.interpret());
1329 }
1330 buf
1331 }
1332}
1333
1334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1335#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1336#[cfg_attr(feature = "bon", builder(on(String, into)))]
1337pub struct ChatSettings {
1338 #[serde(rename = "enableNtfs")]
1339 pub enable_ntfs: MsgFilter,
1340
1341 #[serde(rename = "sendRcpts", skip_serializing_if = "Option::is_none")]
1342 pub send_rcpts: Option<bool>,
1343
1344 #[serde(rename = "favorite")]
1345 pub favorite: bool,
1346
1347 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1348 #[cfg_attr(feature = "bon", builder(default))]
1349 pub undocumented: BTreeMap<String, JsonObject>,
1350}
1351
1352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1353#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1354#[cfg_attr(feature = "bon", builder(on(String, into)))]
1355pub struct ChatStats {
1356 #[serde(
1357 rename = "unreadCount",
1358 deserialize_with = "deserialize_number_from_string"
1359 )]
1360 pub unread_count: i32,
1361
1362 #[serde(
1363 rename = "unreadMentions",
1364 deserialize_with = "deserialize_number_from_string"
1365 )]
1366 pub unread_mentions: i32,
1367
1368 #[serde(
1369 rename = "reportsCount",
1370 deserialize_with = "deserialize_number_from_string"
1371 )]
1372 pub reports_count: i32,
1373
1374 #[serde(
1375 rename = "minUnreadItemId",
1376 deserialize_with = "deserialize_number_from_string"
1377 )]
1378 pub min_unread_item_id: i64,
1379
1380 #[serde(rename = "unreadChat")]
1381 pub unread_chat: bool,
1382
1383 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1384 #[cfg_attr(feature = "bon", builder(default))]
1385 pub undocumented: BTreeMap<String, JsonObject>,
1386}
1387
1388#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1394#[non_exhaustive]
1395pub enum ChatType {
1396 #[default]
1397 #[serde(rename = "direct")]
1398 Direct,
1399 #[serde(rename = "group")]
1400 Group,
1401 #[serde(rename = "local")]
1402 Local,
1403}
1404
1405impl CommandSyntax for ChatType {
1406 fn interpret(&self) -> String {
1407 let mut buf = String::new();
1408 match self {
1409 Self::Direct => {
1410 buf.push('@');
1411 }
1412 Self::Group => {
1413 buf.push('#');
1414 }
1415 Self::Local => {
1416 buf.push('*');
1417 }
1418 }
1419 buf
1420 }
1421}
1422
1423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1424#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1425#[cfg_attr(feature = "bon", builder(on(String, into)))]
1426pub struct ChatWallpaper {
1427 #[serde(rename = "preset", skip_serializing_if = "Option::is_none")]
1428 pub preset: Option<String>,
1429
1430 #[serde(rename = "imageFile", skip_serializing_if = "Option::is_none")]
1431 pub image_file: Option<String>,
1432
1433 #[serde(rename = "background", skip_serializing_if = "Option::is_none")]
1434 pub background: Option<String>,
1435
1436 #[serde(rename = "tint", skip_serializing_if = "Option::is_none")]
1437 pub tint: Option<String>,
1438
1439 #[serde(rename = "scaleType", skip_serializing_if = "Option::is_none")]
1440 pub scale_type: Option<ChatWallpaperScale>,
1441
1442 #[serde(
1443 rename = "scale",
1444 skip_serializing_if = "Option::is_none",
1445 deserialize_with = "deserialize_option_number_from_string",
1446 default
1447 )]
1448 pub scale: Option<f64>,
1449
1450 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1451 #[cfg_attr(feature = "bon", builder(default))]
1452 pub undocumented: BTreeMap<String, JsonObject>,
1453}
1454
1455#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1456#[non_exhaustive]
1457pub enum ChatWallpaperScale {
1458 #[default]
1459 #[serde(rename = "fill")]
1460 Fill,
1461 #[serde(rename = "fit")]
1462 Fit,
1463 #[serde(rename = "repeat")]
1464 Repeat,
1465}
1466
1467#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1468#[non_exhaustive]
1469pub enum Color {
1470 #[default]
1471 #[serde(rename = "black")]
1472 Black,
1473 #[serde(rename = "red")]
1474 Red,
1475 #[serde(rename = "green")]
1476 Green,
1477 #[serde(rename = "yellow")]
1478 Yellow,
1479 #[serde(rename = "blue")]
1480 Blue,
1481 #[serde(rename = "magenta")]
1482 Magenta,
1483 #[serde(rename = "cyan")]
1484 Cyan,
1485 #[serde(rename = "white")]
1486 White,
1487}
1488
1489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1490#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1491#[cfg_attr(feature = "bon", builder(on(String, into)))]
1492pub struct ComposedMessage {
1493 #[serde(rename = "fileSource", skip_serializing_if = "Option::is_none")]
1494 pub file_source: Option<CryptoFile>,
1495
1496 #[serde(
1497 rename = "quotedItemId",
1498 skip_serializing_if = "Option::is_none",
1499 deserialize_with = "deserialize_option_number_from_string",
1500 default
1501 )]
1502 pub quoted_item_id: Option<i64>,
1503
1504 #[serde(rename = "msgContent")]
1505 pub msg_content: MsgContent,
1506
1507 #[serde(rename = "mentions")]
1508 pub mentions: HashMap<String, i64>,
1509
1510 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1511 #[cfg_attr(feature = "bon", builder(default))]
1512 pub undocumented: BTreeMap<String, JsonObject>,
1513}
1514
1515#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1516#[non_exhaustive]
1517pub enum ConnStatus {
1518 #[default]
1519 #[serde(rename = "new")]
1520 New,
1521 #[serde(rename = "prepared")]
1522 Prepared,
1523 #[serde(rename = "joined")]
1524 Joined,
1525 #[serde(rename = "requested")]
1526 Requested,
1527 #[serde(rename = "accepted")]
1528 Accepted,
1529 #[serde(rename = "snd-ready")]
1530 SndReady,
1531 #[serde(rename = "ready")]
1532 Ready,
1533 #[serde(rename = "deleted")]
1534 Deleted,
1535}
1536
1537#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1538#[non_exhaustive]
1539pub enum ConnType {
1540 #[default]
1541 #[serde(rename = "contact")]
1542 Contact,
1543 #[serde(rename = "member")]
1544 Member,
1545 #[serde(rename = "user_contact")]
1546 UserContact,
1547}
1548
1549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1550#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1551#[cfg_attr(feature = "bon", builder(on(String, into)))]
1552pub struct Connection {
1553 #[serde(rename = "connId", deserialize_with = "deserialize_number_from_string")]
1554 pub conn_id: i64,
1555
1556 #[serde(rename = "agentConnId")]
1557 pub agent_conn_id: String,
1558
1559 #[serde(
1560 rename = "connChatVersion",
1561 deserialize_with = "deserialize_number_from_string"
1562 )]
1563 pub conn_chat_version: i32,
1564
1565 #[serde(rename = "peerChatVRange")]
1566 pub peer_chat_v_range: VersionRange,
1567
1568 #[serde(
1569 rename = "connLevel",
1570 deserialize_with = "deserialize_number_from_string"
1571 )]
1572 pub conn_level: i32,
1573
1574 #[serde(
1575 rename = "viaContact",
1576 skip_serializing_if = "Option::is_none",
1577 deserialize_with = "deserialize_option_number_from_string",
1578 default
1579 )]
1580 pub via_contact: Option<i64>,
1581
1582 #[serde(
1583 rename = "viaUserContactLink",
1584 skip_serializing_if = "Option::is_none",
1585 deserialize_with = "deserialize_option_number_from_string",
1586 default
1587 )]
1588 pub via_user_contact_link: Option<i64>,
1589
1590 #[serde(rename = "viaGroupLink")]
1591 pub via_group_link: bool,
1592
1593 #[serde(rename = "groupLinkId", skip_serializing_if = "Option::is_none")]
1594 pub group_link_id: Option<String>,
1595
1596 #[serde(rename = "xContactId", skip_serializing_if = "Option::is_none")]
1597 pub x_contact_id: Option<String>,
1598
1599 #[serde(
1600 rename = "customUserProfileId",
1601 skip_serializing_if = "Option::is_none",
1602 deserialize_with = "deserialize_option_number_from_string",
1603 default
1604 )]
1605 pub custom_user_profile_id: Option<i64>,
1606
1607 #[serde(rename = "connType")]
1608 pub conn_type: ConnType,
1609
1610 #[serde(rename = "connStatus")]
1611 pub conn_status: ConnStatus,
1612
1613 #[serde(rename = "contactConnInitiated")]
1614 pub contact_conn_initiated: bool,
1615
1616 #[serde(rename = "localAlias")]
1617 pub local_alias: String,
1618
1619 #[serde(
1620 rename = "entityId",
1621 skip_serializing_if = "Option::is_none",
1622 deserialize_with = "deserialize_option_number_from_string",
1623 default
1624 )]
1625 pub entity_id: Option<i64>,
1626
1627 #[serde(rename = "connectionCode", skip_serializing_if = "Option::is_none")]
1628 pub connection_code: Option<SecurityCode>,
1629
1630 #[serde(rename = "pqSupport")]
1631 pub pq_support: bool,
1632
1633 #[serde(rename = "pqEncryption")]
1634 pub pq_encryption: bool,
1635
1636 #[serde(rename = "pqSndEnabled", skip_serializing_if = "Option::is_none")]
1637 pub pq_snd_enabled: Option<bool>,
1638
1639 #[serde(rename = "pqRcvEnabled", skip_serializing_if = "Option::is_none")]
1640 pub pq_rcv_enabled: Option<bool>,
1641
1642 #[serde(
1643 rename = "authErrCounter",
1644 deserialize_with = "deserialize_number_from_string"
1645 )]
1646 pub auth_err_counter: i32,
1647
1648 #[serde(
1649 rename = "quotaErrCounter",
1650 deserialize_with = "deserialize_number_from_string"
1651 )]
1652 pub quota_err_counter: i32,
1653
1654 #[serde(rename = "createdAt")]
1655 pub created_at: UtcTime,
1656
1657 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1658 #[cfg_attr(feature = "bon", builder(default))]
1659 pub undocumented: BTreeMap<String, JsonObject>,
1660}
1661
1662#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1663#[serde(tag = "type")]
1664#[non_exhaustive]
1665pub enum ConnectionEntity {
1666 #[serde(rename = "rcvDirectMsgConnection")]
1667 RcvDirectMsgConnection {
1668 #[serde(rename = "entityConnection")]
1669 entity_connection: Connection,
1670
1671 #[serde(rename = "contact", skip_serializing_if = "Option::is_none")]
1672 contact: Option<Contact>,
1673
1674 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1675 undocumented: BTreeMap<String, JsonObject>,
1676 },
1677 #[serde(rename = "rcvGroupMsgConnection")]
1678 RcvGroupMsgConnection {
1679 #[serde(rename = "entityConnection")]
1680 entity_connection: Connection,
1681
1682 #[serde(rename = "groupInfo")]
1683 group_info: GroupInfo,
1684
1685 #[serde(rename = "groupMember")]
1686 group_member: GroupMember,
1687
1688 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1689 undocumented: BTreeMap<String, JsonObject>,
1690 },
1691 #[serde(rename = "sndFileConnection")]
1692 SndFileConnection {
1693 #[serde(rename = "entityConnection")]
1694 entity_connection: Connection,
1695
1696 #[serde(rename = "sndFileTransfer")]
1697 snd_file_transfer: SndFileTransfer,
1698
1699 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1700 undocumented: BTreeMap<String, JsonObject>,
1701 },
1702 #[serde(rename = "rcvFileConnection")]
1703 RcvFileConnection {
1704 #[serde(rename = "entityConnection")]
1705 entity_connection: Connection,
1706
1707 #[serde(rename = "rcvFileTransfer")]
1708 rcv_file_transfer: RcvFileTransfer,
1709
1710 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1711 undocumented: BTreeMap<String, JsonObject>,
1712 },
1713 #[serde(rename = "userContactConnection")]
1714 UserContactConnection {
1715 #[serde(rename = "entityConnection")]
1716 entity_connection: Connection,
1717
1718 #[serde(rename = "userContact")]
1719 user_contact: UserContact,
1720
1721 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1722 undocumented: BTreeMap<String, JsonObject>,
1723 },
1724 #[serde(untagged)]
1725 Undocumented(BTreeMap<String, JsonObject>),
1726}
1727
1728#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1729#[non_exhaustive]
1730pub enum ConnectionMode {
1731 #[default]
1732 #[serde(rename = "inv")]
1733 Inv,
1734 #[serde(rename = "con")]
1735 Con,
1736}
1737
1738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1739#[serde(tag = "type")]
1740#[non_exhaustive]
1741pub enum ConnectionPlan {
1742 #[serde(rename = "invitationLink")]
1743 InvitationLink {
1744 #[serde(rename = "invitationLinkPlan")]
1745 invitation_link_plan: InvitationLinkPlan,
1746
1747 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1748 undocumented: BTreeMap<String, JsonObject>,
1749 },
1750 #[serde(rename = "contactAddress")]
1751 ContactAddress {
1752 #[serde(rename = "contactAddressPlan")]
1753 contact_address_plan: ContactAddressPlan,
1754
1755 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1756 undocumented: BTreeMap<String, JsonObject>,
1757 },
1758 #[serde(rename = "groupLink")]
1759 GroupLink {
1760 #[serde(rename = "groupLinkPlan")]
1761 group_link_plan: GroupLinkPlan,
1762
1763 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1764 undocumented: BTreeMap<String, JsonObject>,
1765 },
1766 #[serde(rename = "error")]
1767 Error {
1768 #[serde(rename = "chatError")]
1769 chat_error: ChatError,
1770
1771 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1772 undocumented: BTreeMap<String, JsonObject>,
1773 },
1774 #[serde(untagged)]
1775 Undocumented(BTreeMap<String, JsonObject>),
1776}
1777
1778#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1779#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1780#[cfg_attr(feature = "bon", builder(on(String, into)))]
1781pub struct Contact {
1782 #[serde(
1783 rename = "contactId",
1784 deserialize_with = "deserialize_number_from_string"
1785 )]
1786 pub contact_id: i64,
1787
1788 #[serde(rename = "localDisplayName")]
1789 pub local_display_name: String,
1790
1791 #[serde(rename = "profile")]
1792 pub profile: LocalProfile,
1793
1794 #[serde(rename = "activeConn", skip_serializing_if = "Option::is_none")]
1795 pub active_conn: Option<Connection>,
1796
1797 #[serde(
1798 rename = "viaGroup",
1799 skip_serializing_if = "Option::is_none",
1800 deserialize_with = "deserialize_option_number_from_string",
1801 default
1802 )]
1803 pub via_group: Option<i64>,
1804
1805 #[serde(rename = "contactUsed")]
1806 pub contact_used: bool,
1807
1808 #[serde(rename = "contactStatus")]
1809 pub contact_status: ContactStatus,
1810
1811 #[serde(rename = "chatSettings")]
1812 pub chat_settings: ChatSettings,
1813
1814 #[serde(rename = "userPreferences")]
1815 pub user_preferences: Preferences,
1816
1817 #[serde(rename = "mergedPreferences")]
1818 pub merged_preferences: ContactUserPreferences,
1819
1820 #[serde(rename = "createdAt")]
1821 pub created_at: UtcTime,
1822
1823 #[serde(rename = "updatedAt")]
1824 pub updated_at: UtcTime,
1825
1826 #[serde(rename = "chatTs", skip_serializing_if = "Option::is_none")]
1827 pub chat_ts: Option<UtcTime>,
1828
1829 #[serde(rename = "preparedContact", skip_serializing_if = "Option::is_none")]
1830 pub prepared_contact: Option<PreparedContact>,
1831
1832 #[serde(
1833 rename = "contactRequestId",
1834 skip_serializing_if = "Option::is_none",
1835 deserialize_with = "deserialize_option_number_from_string",
1836 default
1837 )]
1838 pub contact_request_id: Option<i64>,
1839
1840 #[serde(
1841 rename = "contactGroupMemberId",
1842 skip_serializing_if = "Option::is_none",
1843 deserialize_with = "deserialize_option_number_from_string",
1844 default
1845 )]
1846 pub contact_group_member_id: Option<i64>,
1847
1848 #[serde(rename = "contactGrpInvSent")]
1849 pub contact_grp_inv_sent: bool,
1850
1851 #[serde(rename = "groupDirectInv", skip_serializing_if = "Option::is_none")]
1852 pub group_direct_inv: Option<GroupDirectInvitation>,
1853
1854 #[serde(rename = "chatTags")]
1855 pub chat_tags: Vec<i64>,
1856
1857 #[serde(
1858 rename = "chatItemTTL",
1859 skip_serializing_if = "Option::is_none",
1860 deserialize_with = "deserialize_option_number_from_string",
1861 default
1862 )]
1863 pub chat_item_ttl: Option<i64>,
1864
1865 #[serde(rename = "uiThemes", skip_serializing_if = "Option::is_none")]
1866 pub ui_themes: Option<UIThemeEntityOverrides>,
1867
1868 #[serde(rename = "chatDeleted")]
1869 pub chat_deleted: bool,
1870
1871 #[serde(rename = "customData", skip_serializing_if = "Option::is_none")]
1872 pub custom_data: Option<JsonObject>,
1873
1874 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1875 #[cfg_attr(feature = "bon", builder(default))]
1876 pub undocumented: BTreeMap<String, JsonObject>,
1877}
1878
1879#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1880#[serde(tag = "type")]
1881#[non_exhaustive]
1882pub enum ContactAddressPlan {
1883 #[serde(rename = "ok")]
1884 Ok {
1885 #[serde(rename = "contactSLinkData_", skip_serializing_if = "Option::is_none")]
1886 contact_s_link_data: Option<ContactShortLinkData>,
1887
1888 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1889 undocumented: BTreeMap<String, JsonObject>,
1890 },
1891 #[serde(rename = "ownLink")]
1892 OwnLink,
1893 #[serde(rename = "connectingConfirmReconnect")]
1894 ConnectingConfirmReconnect,
1895 #[serde(rename = "connectingProhibit")]
1896 ConnectingProhibit {
1897 #[serde(rename = "contact")]
1898 contact: Contact,
1899
1900 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1901 undocumented: BTreeMap<String, JsonObject>,
1902 },
1903 #[serde(rename = "known")]
1904 Known {
1905 #[serde(rename = "contact")]
1906 contact: Contact,
1907
1908 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1909 undocumented: BTreeMap<String, JsonObject>,
1910 },
1911 #[serde(rename = "contactViaAddress")]
1912 ContactViaAddress {
1913 #[serde(rename = "contact")]
1914 contact: Contact,
1915
1916 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1917 undocumented: BTreeMap<String, JsonObject>,
1918 },
1919 #[serde(untagged)]
1920 Undocumented(BTreeMap<String, JsonObject>),
1921}
1922
1923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1924#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1925#[cfg_attr(feature = "bon", builder(on(String, into)))]
1926pub struct ContactShortLinkData {
1927 #[serde(rename = "profile")]
1928 pub profile: Profile,
1929
1930 #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
1931 pub message: Option<MsgContent>,
1932
1933 #[serde(rename = "business")]
1934 pub business: bool,
1935
1936 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1937 #[cfg_attr(feature = "bon", builder(default))]
1938 pub undocumented: BTreeMap<String, JsonObject>,
1939}
1940
1941#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
1942#[non_exhaustive]
1943pub enum ContactStatus {
1944 #[default]
1945 #[serde(rename = "active")]
1946 Active,
1947 #[serde(rename = "deleted")]
1948 Deleted,
1949 #[serde(rename = "deletedByUser")]
1950 DeletedByUser,
1951}
1952
1953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1954#[serde(tag = "type")]
1955#[non_exhaustive]
1956pub enum ContactUserPref {
1957 #[serde(rename = "contact")]
1958 Contact {
1959 #[serde(rename = "preference")]
1960 preference: SimplePreference,
1961
1962 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1963 undocumented: BTreeMap<String, JsonObject>,
1964 },
1965 #[serde(rename = "user")]
1966 User {
1967 #[serde(rename = "preference")]
1968 preference: SimplePreference,
1969
1970 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1971 undocumented: BTreeMap<String, JsonObject>,
1972 },
1973 #[serde(untagged)]
1974 Undocumented(BTreeMap<String, JsonObject>),
1975}
1976
1977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1978#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1979#[cfg_attr(feature = "bon", builder(on(String, into)))]
1980pub struct ContactUserPreference {
1981 #[serde(rename = "enabled")]
1982 pub enabled: PrefEnabled,
1983
1984 #[serde(rename = "userPreference")]
1985 pub user_preference: ContactUserPref,
1986
1987 #[serde(rename = "contactPreference")]
1988 pub contact_preference: SimplePreference,
1989
1990 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
1991 #[cfg_attr(feature = "bon", builder(default))]
1992 pub undocumented: BTreeMap<String, JsonObject>,
1993}
1994
1995#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1996#[cfg_attr(feature = "bon", derive(::bon::Builder))]
1997#[cfg_attr(feature = "bon", builder(on(String, into)))]
1998pub struct ContactUserPreferences {
1999 #[serde(rename = "timedMessages")]
2000 pub timed_messages: ContactUserPreference,
2001
2002 #[serde(rename = "fullDelete")]
2003 pub full_delete: ContactUserPreference,
2004
2005 #[serde(rename = "reactions")]
2006 pub reactions: ContactUserPreference,
2007
2008 #[serde(rename = "voice")]
2009 pub voice: ContactUserPreference,
2010
2011 #[serde(rename = "files")]
2012 pub files: ContactUserPreference,
2013
2014 #[serde(rename = "calls")]
2015 pub calls: ContactUserPreference,
2016
2017 #[serde(rename = "sessions")]
2018 pub sessions: ContactUserPreference,
2019
2020 #[serde(rename = "commands", skip_serializing_if = "Option::is_none")]
2021 pub commands: Option<Vec<ChatBotCommand>>,
2022
2023 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2024 #[cfg_attr(feature = "bon", builder(default))]
2025 pub undocumented: BTreeMap<String, JsonObject>,
2026}
2027
2028#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2034#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2035#[cfg_attr(feature = "bon", builder(on(String, into)))]
2036pub struct CreatedConnLink {
2037 #[serde(rename = "connFullLink")]
2038 pub conn_full_link: String,
2039
2040 #[serde(rename = "connShortLink", skip_serializing_if = "Option::is_none")]
2041 pub conn_short_link: Option<String>,
2042
2043 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2044 #[cfg_attr(feature = "bon", builder(default))]
2045 pub undocumented: BTreeMap<String, JsonObject>,
2046}
2047
2048impl CommandSyntax for CreatedConnLink {
2049 fn interpret(&self) -> String {
2050 let mut buf = String::with_capacity(64);
2051 buf.push_str(&self.conn_full_link.to_string());
2052 if let Some(conn_short_link) = &self.conn_short_link {
2053 buf.push(' ');
2054 buf.push_str(&conn_short_link.to_string());
2055 }
2056 buf
2057 }
2058}
2059
2060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2061#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2062#[cfg_attr(feature = "bon", builder(on(String, into)))]
2063pub struct CryptoFile {
2064 #[serde(rename = "filePath")]
2065 pub file_path: String,
2066
2067 #[serde(rename = "cryptoArgs", skip_serializing_if = "Option::is_none")]
2068 pub crypto_args: Option<CryptoFileArgs>,
2069
2070 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2071 #[cfg_attr(feature = "bon", builder(default))]
2072 pub undocumented: BTreeMap<String, JsonObject>,
2073}
2074
2075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2076#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2077#[cfg_attr(feature = "bon", builder(on(String, into)))]
2078pub struct CryptoFileArgs {
2079 #[serde(rename = "fileKey")]
2080 pub file_key: String,
2081
2082 #[serde(rename = "fileNonce")]
2083 pub file_nonce: String,
2084
2085 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2086 #[cfg_attr(feature = "bon", builder(default))]
2087 pub undocumented: BTreeMap<String, JsonObject>,
2088}
2089
2090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2091#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2092#[cfg_attr(feature = "bon", builder(on(String, into)))]
2093pub struct E2EInfo {
2094 #[serde(rename = "pqEnabled", skip_serializing_if = "Option::is_none")]
2095 pub pq_enabled: Option<bool>,
2096
2097 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2098 #[cfg_attr(feature = "bon", builder(default))]
2099 pub undocumented: BTreeMap<String, JsonObject>,
2100}
2101
2102#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2103#[non_exhaustive]
2104pub enum FeatureAllowed {
2105 #[default]
2106 #[serde(rename = "always")]
2107 Always,
2108 #[serde(rename = "yes")]
2109 Yes,
2110 #[serde(rename = "no")]
2111 No,
2112}
2113
2114#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2115#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2116#[cfg_attr(feature = "bon", builder(on(String, into)))]
2117pub struct FileDescr {
2118 #[serde(rename = "fileDescrText")]
2119 pub file_descr_text: String,
2120
2121 #[serde(
2122 rename = "fileDescrPartNo",
2123 deserialize_with = "deserialize_number_from_string"
2124 )]
2125 pub file_descr_part_no: i32,
2126
2127 #[serde(rename = "fileDescrComplete")]
2128 pub file_descr_complete: bool,
2129
2130 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2131 #[cfg_attr(feature = "bon", builder(default))]
2132 pub undocumented: BTreeMap<String, JsonObject>,
2133}
2134
2135#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2136#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2137#[cfg_attr(feature = "bon", builder(on(String, into)))]
2138pub struct FileInvitation {
2139 #[serde(rename = "fileName")]
2140 pub file_name: String,
2141
2142 #[serde(
2143 rename = "fileSize",
2144 deserialize_with = "deserialize_number_from_string"
2145 )]
2146 pub file_size: i64,
2147
2148 #[serde(rename = "fileDigest", skip_serializing_if = "Option::is_none")]
2149 pub file_digest: Option<String>,
2150
2151 #[serde(rename = "fileConnReq", skip_serializing_if = "Option::is_none")]
2152 pub file_conn_req: Option<String>,
2153
2154 #[serde(rename = "fileInline", skip_serializing_if = "Option::is_none")]
2155 pub file_inline: Option<InlineFileMode>,
2156
2157 #[serde(rename = "fileDescr", skip_serializing_if = "Option::is_none")]
2158 pub file_descr: Option<FileDescr>,
2159
2160 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2161 #[cfg_attr(feature = "bon", builder(default))]
2162 pub undocumented: BTreeMap<String, JsonObject>,
2163}
2164
2165#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2166#[non_exhaustive]
2167pub enum FileProtocol {
2168 #[default]
2169 #[serde(rename = "smp")]
2170 Smp,
2171 #[serde(rename = "xftp")]
2172 Xftp,
2173 #[serde(rename = "local")]
2174 Local,
2175}
2176
2177#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2178#[non_exhaustive]
2179pub enum FileStatus {
2180 #[default]
2181 #[serde(rename = "new")]
2182 New,
2183 #[serde(rename = "accepted")]
2184 Accepted,
2185 #[serde(rename = "connected")]
2186 Connected,
2187 #[serde(rename = "complete")]
2188 Complete,
2189 #[serde(rename = "cancelled")]
2190 Cancelled,
2191}
2192
2193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2194#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2195#[cfg_attr(feature = "bon", builder(on(String, into)))]
2196pub struct FileTransferMeta {
2197 #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
2198 pub file_id: i64,
2199
2200 #[serde(rename = "xftpSndFile", skip_serializing_if = "Option::is_none")]
2201 pub xftp_snd_file: Option<XFTPSndFile>,
2202
2203 #[serde(
2204 rename = "xftpRedirectFor",
2205 skip_serializing_if = "Option::is_none",
2206 deserialize_with = "deserialize_option_number_from_string",
2207 default
2208 )]
2209 pub xftp_redirect_for: Option<i64>,
2210
2211 #[serde(rename = "fileName")]
2212 pub file_name: String,
2213
2214 #[serde(rename = "filePath")]
2215 pub file_path: String,
2216
2217 #[serde(
2218 rename = "fileSize",
2219 deserialize_with = "deserialize_number_from_string"
2220 )]
2221 pub file_size: i64,
2222
2223 #[serde(rename = "fileInline", skip_serializing_if = "Option::is_none")]
2224 pub file_inline: Option<InlineFileMode>,
2225
2226 #[serde(
2227 rename = "chunkSize",
2228 deserialize_with = "deserialize_number_from_string"
2229 )]
2230 pub chunk_size: i64,
2231
2232 #[serde(rename = "cancelled")]
2233 pub cancelled: bool,
2234
2235 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2236 #[cfg_attr(feature = "bon", builder(default))]
2237 pub undocumented: BTreeMap<String, JsonObject>,
2238}
2239
2240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2241#[serde(tag = "type")]
2242#[non_exhaustive]
2243pub enum Format {
2244 #[serde(rename = "bold")]
2245 Bold,
2246 #[serde(rename = "italic")]
2247 Italic,
2248 #[serde(rename = "strikeThrough")]
2249 StrikeThrough,
2250 #[serde(rename = "snippet")]
2251 Snippet,
2252 #[serde(rename = "secret")]
2253 Secret,
2254 #[serde(rename = "colored")]
2255 Colored {
2256 #[serde(rename = "color")]
2257 color: Color,
2258
2259 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2260 undocumented: BTreeMap<String, JsonObject>,
2261 },
2262 #[serde(rename = "uri")]
2263 Uri,
2264 #[serde(rename = "hyperLink")]
2265 HyperLink {
2266 #[serde(rename = "showText", skip_serializing_if = "Option::is_none")]
2267 show_text: Option<String>,
2268
2269 #[serde(rename = "linkUri")]
2270 link_uri: String,
2271
2272 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2273 undocumented: BTreeMap<String, JsonObject>,
2274 },
2275 #[serde(rename = "simplexLink")]
2276 SimplexLink {
2277 #[serde(rename = "showText", skip_serializing_if = "Option::is_none")]
2278 show_text: Option<String>,
2279
2280 #[serde(rename = "linkType")]
2281 link_type: SimplexLinkType,
2282
2283 #[serde(rename = "simplexUri")]
2284 simplex_uri: String,
2285
2286 #[serde(rename = "smpHosts")]
2287 smp_hosts: Vec<String>,
2288
2289 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2290 undocumented: BTreeMap<String, JsonObject>,
2291 },
2292 #[serde(rename = "command")]
2293 Command {
2294 #[serde(rename = "commandStr")]
2295 command_str: String,
2296
2297 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2298 undocumented: BTreeMap<String, JsonObject>,
2299 },
2300 #[serde(rename = "mention")]
2301 Mention {
2302 #[serde(rename = "memberName")]
2303 member_name: String,
2304
2305 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2306 undocumented: BTreeMap<String, JsonObject>,
2307 },
2308 #[serde(rename = "email")]
2309 Email,
2310 #[serde(rename = "phone")]
2311 Phone,
2312 #[serde(untagged)]
2313 Undocumented(BTreeMap<String, JsonObject>),
2314}
2315
2316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2317#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2318#[cfg_attr(feature = "bon", builder(on(String, into)))]
2319pub struct FormattedText {
2320 #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
2321 pub format: Option<Format>,
2322
2323 #[serde(rename = "text")]
2324 pub text: String,
2325
2326 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2327 #[cfg_attr(feature = "bon", builder(default))]
2328 pub undocumented: BTreeMap<String, JsonObject>,
2329}
2330
2331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2332#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2333#[cfg_attr(feature = "bon", builder(on(String, into)))]
2334pub struct FullGroupPreferences {
2335 #[serde(rename = "timedMessages")]
2336 pub timed_messages: TimedMessagesGroupPreference,
2337
2338 #[serde(rename = "directMessages")]
2339 pub direct_messages: RoleGroupPreference,
2340
2341 #[serde(rename = "fullDelete")]
2342 pub full_delete: GroupPreference,
2343
2344 #[serde(rename = "reactions")]
2345 pub reactions: GroupPreference,
2346
2347 #[serde(rename = "voice")]
2348 pub voice: RoleGroupPreference,
2349
2350 #[serde(rename = "files")]
2351 pub files: RoleGroupPreference,
2352
2353 #[serde(rename = "simplexLinks")]
2354 pub simplex_links: RoleGroupPreference,
2355
2356 #[serde(rename = "reports")]
2357 pub reports: GroupPreference,
2358
2359 #[serde(rename = "history")]
2360 pub history: GroupPreference,
2361
2362 #[serde(rename = "sessions")]
2363 pub sessions: RoleGroupPreference,
2364
2365 #[serde(rename = "commands")]
2366 pub commands: Vec<ChatBotCommand>,
2367
2368 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2369 #[cfg_attr(feature = "bon", builder(default))]
2370 pub undocumented: BTreeMap<String, JsonObject>,
2371}
2372
2373#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2374#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2375#[cfg_attr(feature = "bon", builder(on(String, into)))]
2376pub struct FullPreferences {
2377 #[serde(rename = "timedMessages")]
2378 pub timed_messages: TimedMessagesPreference,
2379
2380 #[serde(rename = "fullDelete")]
2381 pub full_delete: SimplePreference,
2382
2383 #[serde(rename = "reactions")]
2384 pub reactions: SimplePreference,
2385
2386 #[serde(rename = "voice")]
2387 pub voice: SimplePreference,
2388
2389 #[serde(rename = "files")]
2390 pub files: SimplePreference,
2391
2392 #[serde(rename = "calls")]
2393 pub calls: SimplePreference,
2394
2395 #[serde(rename = "sessions")]
2396 pub sessions: SimplePreference,
2397
2398 #[serde(rename = "commands")]
2399 pub commands: Vec<ChatBotCommand>,
2400
2401 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2402 #[cfg_attr(feature = "bon", builder(default))]
2403 pub undocumented: BTreeMap<String, JsonObject>,
2404}
2405
2406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2407#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2408#[cfg_attr(feature = "bon", builder(on(String, into)))]
2409pub struct Group {
2410 #[serde(rename = "groupInfo")]
2411 pub group_info: GroupInfo,
2412
2413 #[serde(rename = "members")]
2414 pub members: Vec<GroupMember>,
2415
2416 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2417 #[cfg_attr(feature = "bon", builder(default))]
2418 pub undocumented: BTreeMap<String, JsonObject>,
2419}
2420
2421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2427#[serde(tag = "type")]
2428#[non_exhaustive]
2429pub enum GroupChatScope {
2430 #[serde(rename = "memberSupport")]
2431 MemberSupport {
2432 #[serde(
2433 rename = "groupMemberId_",
2434 skip_serializing_if = "Option::is_none",
2435 deserialize_with = "deserialize_option_number_from_string",
2436 default
2437 )]
2438 group_member_id: Option<i64>,
2439
2440 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2441 undocumented: BTreeMap<String, JsonObject>,
2442 },
2443 #[serde(untagged)]
2444 Undocumented(BTreeMap<String, JsonObject>),
2445}
2446
2447impl CommandSyntax for GroupChatScope {
2448 fn interpret(&self) -> String {
2449 let mut buf = String::with_capacity(64);
2450 buf.push_str("(_support");
2451 match self {
2452 Self::MemberSupport {
2453 group_member_id, ..
2454 } => {
2455 if let Some(group_member_id) = group_member_id {
2456 buf.push(':');
2457 buf.push_str(&group_member_id.to_string());
2458 }
2459 }
2460 Self::Undocumented(_) => {}
2461 }
2462 buf.push(')');
2463 buf
2464 }
2465}
2466
2467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2468#[serde(tag = "type")]
2469#[non_exhaustive]
2470pub enum GroupChatScopeInfo {
2471 #[serde(rename = "memberSupport")]
2472 MemberSupport {
2473 #[serde(rename = "groupMember_", skip_serializing_if = "Option::is_none")]
2474 group_member: Option<GroupMember>,
2475
2476 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2477 undocumented: BTreeMap<String, JsonObject>,
2478 },
2479 #[serde(untagged)]
2480 Undocumented(BTreeMap<String, JsonObject>),
2481}
2482
2483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2484#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2485#[cfg_attr(feature = "bon", builder(on(String, into)))]
2486pub struct GroupDirectInvitation {
2487 #[serde(rename = "groupDirectInvLink")]
2488 pub group_direct_inv_link: String,
2489
2490 #[serde(
2491 rename = "fromGroupId_",
2492 skip_serializing_if = "Option::is_none",
2493 deserialize_with = "deserialize_option_number_from_string",
2494 default
2495 )]
2496 pub from_group_id: Option<i64>,
2497
2498 #[serde(
2499 rename = "fromGroupMemberId_",
2500 skip_serializing_if = "Option::is_none",
2501 deserialize_with = "deserialize_option_number_from_string",
2502 default
2503 )]
2504 pub from_group_member_id: Option<i64>,
2505
2506 #[serde(
2507 rename = "fromGroupMemberConnId_",
2508 skip_serializing_if = "Option::is_none",
2509 deserialize_with = "deserialize_option_number_from_string",
2510 default
2511 )]
2512 pub from_group_member_conn_id: Option<i64>,
2513
2514 #[serde(rename = "groupDirectInvStartedConnection")]
2515 pub group_direct_inv_started_connection: bool,
2516
2517 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2518 #[cfg_attr(feature = "bon", builder(default))]
2519 pub undocumented: BTreeMap<String, JsonObject>,
2520}
2521
2522#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2523#[non_exhaustive]
2524pub enum GroupFeature {
2525 #[default]
2526 #[serde(rename = "timedMessages")]
2527 TimedMessages,
2528 #[serde(rename = "directMessages")]
2529 DirectMessages,
2530 #[serde(rename = "fullDelete")]
2531 FullDelete,
2532 #[serde(rename = "reactions")]
2533 Reactions,
2534 #[serde(rename = "voice")]
2535 Voice,
2536 #[serde(rename = "files")]
2537 Files,
2538 #[serde(rename = "simplexLinks")]
2539 SimplexLinks,
2540 #[serde(rename = "reports")]
2541 Reports,
2542 #[serde(rename = "history")]
2543 History,
2544 #[serde(rename = "sessions")]
2545 Sessions,
2546}
2547
2548#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2549#[non_exhaustive]
2550pub enum GroupFeatureEnabled {
2551 #[default]
2552 #[serde(rename = "on")]
2553 On,
2554 #[serde(rename = "off")]
2555 Off,
2556}
2557
2558#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2559#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2560#[cfg_attr(feature = "bon", builder(on(String, into)))]
2561pub struct GroupInfo {
2562 #[serde(
2563 rename = "groupId",
2564 deserialize_with = "deserialize_number_from_string"
2565 )]
2566 pub group_id: i64,
2567
2568 #[serde(rename = "localDisplayName")]
2569 pub local_display_name: String,
2570
2571 #[serde(rename = "groupProfile")]
2572 pub group_profile: GroupProfile,
2573
2574 #[serde(rename = "localAlias")]
2575 pub local_alias: String,
2576
2577 #[serde(rename = "businessChat", skip_serializing_if = "Option::is_none")]
2578 pub business_chat: Option<BusinessChatInfo>,
2579
2580 #[serde(rename = "fullGroupPreferences")]
2581 pub full_group_preferences: FullGroupPreferences,
2582
2583 #[serde(rename = "membership")]
2584 pub membership: GroupMember,
2585
2586 #[serde(rename = "chatSettings")]
2587 pub chat_settings: ChatSettings,
2588
2589 #[serde(rename = "createdAt")]
2590 pub created_at: UtcTime,
2591
2592 #[serde(rename = "updatedAt")]
2593 pub updated_at: UtcTime,
2594
2595 #[serde(rename = "chatTs", skip_serializing_if = "Option::is_none")]
2596 pub chat_ts: Option<UtcTime>,
2597
2598 #[serde(
2599 rename = "userMemberProfileSentAt",
2600 skip_serializing_if = "Option::is_none"
2601 )]
2602 pub user_member_profile_sent_at: Option<UtcTime>,
2603
2604 #[serde(rename = "preparedGroup", skip_serializing_if = "Option::is_none")]
2605 pub prepared_group: Option<PreparedGroup>,
2606
2607 #[serde(rename = "chatTags")]
2608 pub chat_tags: Vec<i64>,
2609
2610 #[serde(
2611 rename = "chatItemTTL",
2612 skip_serializing_if = "Option::is_none",
2613 deserialize_with = "deserialize_option_number_from_string",
2614 default
2615 )]
2616 pub chat_item_ttl: Option<i64>,
2617
2618 #[serde(rename = "uiThemes", skip_serializing_if = "Option::is_none")]
2619 pub ui_themes: Option<UIThemeEntityOverrides>,
2620
2621 #[serde(rename = "customData", skip_serializing_if = "Option::is_none")]
2622 pub custom_data: Option<JsonObject>,
2623
2624 #[serde(
2625 rename = "membersRequireAttention",
2626 deserialize_with = "deserialize_number_from_string"
2627 )]
2628 pub members_require_attention: i32,
2629
2630 #[serde(rename = "viaGroupLinkUri", skip_serializing_if = "Option::is_none")]
2631 pub via_group_link_uri: Option<String>,
2632
2633 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2634 #[cfg_attr(feature = "bon", builder(default))]
2635 pub undocumented: BTreeMap<String, JsonObject>,
2636}
2637
2638#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2639#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2640#[cfg_attr(feature = "bon", builder(on(String, into)))]
2641pub struct GroupInfoSummary {
2642 #[serde(rename = "groupInfo")]
2643 pub group_info: GroupInfo,
2644
2645 #[serde(rename = "groupSummary")]
2646 pub group_summary: GroupSummary,
2647
2648 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2649 #[cfg_attr(feature = "bon", builder(default))]
2650 pub undocumented: BTreeMap<String, JsonObject>,
2651}
2652
2653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2654#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2655#[cfg_attr(feature = "bon", builder(on(String, into)))]
2656pub struct GroupLink {
2657 #[serde(
2658 rename = "userContactLinkId",
2659 deserialize_with = "deserialize_number_from_string"
2660 )]
2661 pub user_contact_link_id: i64,
2662
2663 #[serde(rename = "connLinkContact")]
2664 pub conn_link_contact: CreatedConnLink,
2665
2666 #[serde(rename = "shortLinkDataSet")]
2667 pub short_link_data_set: bool,
2668
2669 #[serde(rename = "shortLinkLargeDataSet")]
2670 pub short_link_large_data_set: bool,
2671
2672 #[serde(rename = "groupLinkId")]
2673 pub group_link_id: String,
2674
2675 #[serde(rename = "acceptMemberRole")]
2676 pub accept_member_role: GroupMemberRole,
2677
2678 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2679 #[cfg_attr(feature = "bon", builder(default))]
2680 pub undocumented: BTreeMap<String, JsonObject>,
2681}
2682
2683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2684#[serde(tag = "type")]
2685#[non_exhaustive]
2686pub enum GroupLinkPlan {
2687 #[serde(rename = "ok")]
2688 Ok {
2689 #[serde(rename = "groupSLinkData_", skip_serializing_if = "Option::is_none")]
2690 group_s_link_data: Option<GroupShortLinkData>,
2691
2692 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2693 undocumented: BTreeMap<String, JsonObject>,
2694 },
2695 #[serde(rename = "ownLink")]
2696 OwnLink {
2697 #[serde(rename = "groupInfo")]
2698 group_info: GroupInfo,
2699
2700 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2701 undocumented: BTreeMap<String, JsonObject>,
2702 },
2703 #[serde(rename = "connectingConfirmReconnect")]
2704 ConnectingConfirmReconnect,
2705 #[serde(rename = "connectingProhibit")]
2706 ConnectingProhibit {
2707 #[serde(rename = "groupInfo_", skip_serializing_if = "Option::is_none")]
2708 group_info: Option<GroupInfo>,
2709
2710 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2711 undocumented: BTreeMap<String, JsonObject>,
2712 },
2713 #[serde(rename = "known")]
2714 Known {
2715 #[serde(rename = "groupInfo")]
2716 group_info: GroupInfo,
2717
2718 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2719 undocumented: BTreeMap<String, JsonObject>,
2720 },
2721 #[serde(untagged)]
2722 Undocumented(BTreeMap<String, JsonObject>),
2723}
2724
2725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2726#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2727#[cfg_attr(feature = "bon", builder(on(String, into)))]
2728pub struct GroupMember {
2729 #[serde(
2730 rename = "groupMemberId",
2731 deserialize_with = "deserialize_number_from_string"
2732 )]
2733 pub group_member_id: i64,
2734
2735 #[serde(
2736 rename = "groupId",
2737 deserialize_with = "deserialize_number_from_string"
2738 )]
2739 pub group_id: i64,
2740
2741 #[serde(rename = "memberId")]
2742 pub member_id: String,
2743
2744 #[serde(rename = "memberRole")]
2745 pub member_role: GroupMemberRole,
2746
2747 #[serde(rename = "memberCategory")]
2748 pub member_category: GroupMemberCategory,
2749
2750 #[serde(rename = "memberStatus")]
2751 pub member_status: GroupMemberStatus,
2752
2753 #[serde(rename = "memberSettings")]
2754 pub member_settings: GroupMemberSettings,
2755
2756 #[serde(rename = "blockedByAdmin")]
2757 pub blocked_by_admin: bool,
2758
2759 #[serde(rename = "invitedBy")]
2760 pub invited_by: InvitedBy,
2761
2762 #[serde(
2763 rename = "invitedByGroupMemberId",
2764 skip_serializing_if = "Option::is_none",
2765 deserialize_with = "deserialize_option_number_from_string",
2766 default
2767 )]
2768 pub invited_by_group_member_id: Option<i64>,
2769
2770 #[serde(rename = "localDisplayName")]
2771 pub local_display_name: String,
2772
2773 #[serde(rename = "memberProfile")]
2774 pub member_profile: LocalProfile,
2775
2776 #[serde(
2777 rename = "memberContactId",
2778 skip_serializing_if = "Option::is_none",
2779 deserialize_with = "deserialize_option_number_from_string",
2780 default
2781 )]
2782 pub member_contact_id: Option<i64>,
2783
2784 #[serde(
2785 rename = "memberContactProfileId",
2786 deserialize_with = "deserialize_number_from_string"
2787 )]
2788 pub member_contact_profile_id: i64,
2789
2790 #[serde(rename = "activeConn", skip_serializing_if = "Option::is_none")]
2791 pub active_conn: Option<Connection>,
2792
2793 #[serde(rename = "memberChatVRange")]
2794 pub member_chat_v_range: VersionRange,
2795
2796 #[serde(rename = "createdAt")]
2797 pub created_at: UtcTime,
2798
2799 #[serde(rename = "updatedAt")]
2800 pub updated_at: UtcTime,
2801
2802 #[serde(rename = "supportChat", skip_serializing_if = "Option::is_none")]
2803 pub support_chat: Option<GroupSupportChat>,
2804
2805 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2806 #[cfg_attr(feature = "bon", builder(default))]
2807 pub undocumented: BTreeMap<String, JsonObject>,
2808}
2809
2810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2811#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2812#[cfg_attr(feature = "bon", builder(on(String, into)))]
2813pub struct GroupMemberAdmission {
2814 #[serde(rename = "review", skip_serializing_if = "Option::is_none")]
2815 pub review: Option<MemberCriteria>,
2816
2817 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2818 #[cfg_attr(feature = "bon", builder(default))]
2819 pub undocumented: BTreeMap<String, JsonObject>,
2820}
2821
2822#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2823#[non_exhaustive]
2824pub enum GroupMemberCategory {
2825 #[default]
2826 #[serde(rename = "user")]
2827 User,
2828 #[serde(rename = "invitee")]
2829 Invitee,
2830 #[serde(rename = "host")]
2831 Host,
2832 #[serde(rename = "pre")]
2833 Pre,
2834 #[serde(rename = "post")]
2835 Post,
2836}
2837
2838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2839#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2840#[cfg_attr(feature = "bon", builder(on(String, into)))]
2841pub struct GroupMemberRef {
2842 #[serde(
2843 rename = "groupMemberId",
2844 deserialize_with = "deserialize_number_from_string"
2845 )]
2846 pub group_member_id: i64,
2847
2848 #[serde(rename = "profile")]
2849 pub profile: Profile,
2850
2851 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2852 #[cfg_attr(feature = "bon", builder(default))]
2853 pub undocumented: BTreeMap<String, JsonObject>,
2854}
2855
2856#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2857#[non_exhaustive]
2858pub enum GroupMemberRole {
2859 #[default]
2860 #[serde(rename = "observer")]
2861 Observer,
2862 #[serde(rename = "author")]
2863 Author,
2864 #[serde(rename = "member")]
2865 Member,
2866 #[serde(rename = "moderator")]
2867 Moderator,
2868 #[serde(rename = "admin")]
2869 Admin,
2870 #[serde(rename = "owner")]
2871 Owner,
2872}
2873
2874#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2875#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2876#[cfg_attr(feature = "bon", builder(on(String, into)))]
2877pub struct GroupMemberSettings {
2878 #[serde(rename = "showMessages")]
2879 pub show_messages: bool,
2880
2881 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2882 #[cfg_attr(feature = "bon", builder(default))]
2883 pub undocumented: BTreeMap<String, JsonObject>,
2884}
2885
2886#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2887#[non_exhaustive]
2888pub enum GroupMemberStatus {
2889 #[default]
2890 #[serde(rename = "rejected")]
2891 Rejected,
2892 #[serde(rename = "removed")]
2893 Removed,
2894 #[serde(rename = "left")]
2895 Left,
2896 #[serde(rename = "deleted")]
2897 Deleted,
2898 #[serde(rename = "unknown")]
2899 Unknown,
2900 #[serde(rename = "invited")]
2901 Invited,
2902 #[serde(rename = "pending_approval")]
2903 PendingApproval,
2904 #[serde(rename = "pending_review")]
2905 PendingReview,
2906 #[serde(rename = "introduced")]
2907 Introduced,
2908 #[serde(rename = "intro-inv")]
2909 IntroInv,
2910 #[serde(rename = "accepted")]
2911 Accepted,
2912 #[serde(rename = "announced")]
2913 Announced,
2914 #[serde(rename = "connected")]
2915 Connected,
2916 #[serde(rename = "complete")]
2917 Complete,
2918 #[serde(rename = "creator")]
2919 Creator,
2920}
2921
2922#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2923#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2924#[cfg_attr(feature = "bon", builder(on(String, into)))]
2925pub struct GroupPreference {
2926 #[serde(rename = "enable")]
2927 pub enable: GroupFeatureEnabled,
2928
2929 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2930 #[cfg_attr(feature = "bon", builder(default))]
2931 pub undocumented: BTreeMap<String, JsonObject>,
2932}
2933
2934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2935#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2936#[cfg_attr(feature = "bon", builder(on(String, into)))]
2937pub struct GroupPreferences {
2938 #[serde(rename = "timedMessages", skip_serializing_if = "Option::is_none")]
2939 pub timed_messages: Option<TimedMessagesGroupPreference>,
2940
2941 #[serde(rename = "directMessages", skip_serializing_if = "Option::is_none")]
2942 pub direct_messages: Option<RoleGroupPreference>,
2943
2944 #[serde(rename = "fullDelete", skip_serializing_if = "Option::is_none")]
2945 pub full_delete: Option<GroupPreference>,
2946
2947 #[serde(rename = "reactions", skip_serializing_if = "Option::is_none")]
2948 pub reactions: Option<GroupPreference>,
2949
2950 #[serde(rename = "voice", skip_serializing_if = "Option::is_none")]
2951 pub voice: Option<RoleGroupPreference>,
2952
2953 #[serde(rename = "files", skip_serializing_if = "Option::is_none")]
2954 pub files: Option<RoleGroupPreference>,
2955
2956 #[serde(rename = "simplexLinks", skip_serializing_if = "Option::is_none")]
2957 pub simplex_links: Option<RoleGroupPreference>,
2958
2959 #[serde(rename = "reports", skip_serializing_if = "Option::is_none")]
2960 pub reports: Option<GroupPreference>,
2961
2962 #[serde(rename = "history", skip_serializing_if = "Option::is_none")]
2963 pub history: Option<GroupPreference>,
2964
2965 #[serde(rename = "sessions", skip_serializing_if = "Option::is_none")]
2966 pub sessions: Option<RoleGroupPreference>,
2967
2968 #[serde(rename = "commands", skip_serializing_if = "Option::is_none")]
2969 pub commands: Option<Vec<ChatBotCommand>>,
2970
2971 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
2972 #[cfg_attr(feature = "bon", builder(default))]
2973 pub undocumented: BTreeMap<String, JsonObject>,
2974}
2975
2976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2977#[cfg_attr(feature = "bon", derive(::bon::Builder))]
2978#[cfg_attr(feature = "bon", builder(on(String, into)))]
2979pub struct GroupProfile {
2980 #[serde(rename = "displayName")]
2981 pub display_name: String,
2982
2983 #[serde(rename = "fullName")]
2984 pub full_name: String,
2985
2986 #[serde(rename = "shortDescr", skip_serializing_if = "Option::is_none")]
2987 pub short_descr: Option<String>,
2988
2989 #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
2990 pub description: Option<String>,
2991
2992 #[serde(rename = "image", skip_serializing_if = "Option::is_none")]
2993 pub image: Option<String>,
2994
2995 #[serde(rename = "groupPreferences", skip_serializing_if = "Option::is_none")]
2996 pub group_preferences: Option<GroupPreferences>,
2997
2998 #[serde(rename = "memberAdmission", skip_serializing_if = "Option::is_none")]
2999 pub member_admission: Option<GroupMemberAdmission>,
3000
3001 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3002 #[cfg_attr(feature = "bon", builder(default))]
3003 pub undocumented: BTreeMap<String, JsonObject>,
3004}
3005
3006#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3007#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3008#[cfg_attr(feature = "bon", builder(on(String, into)))]
3009pub struct GroupShortLinkData {
3010 #[serde(rename = "groupProfile")]
3011 pub group_profile: GroupProfile,
3012
3013 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3014 #[cfg_attr(feature = "bon", builder(default))]
3015 pub undocumented: BTreeMap<String, JsonObject>,
3016}
3017
3018#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3019#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3020#[cfg_attr(feature = "bon", builder(on(String, into)))]
3021pub struct GroupSummary {
3022 #[serde(
3023 rename = "currentMembers",
3024 deserialize_with = "deserialize_number_from_string"
3025 )]
3026 pub current_members: i32,
3027
3028 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3029 #[cfg_attr(feature = "bon", builder(default))]
3030 pub undocumented: BTreeMap<String, JsonObject>,
3031}
3032
3033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3034#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3035#[cfg_attr(feature = "bon", builder(on(String, into)))]
3036pub struct GroupSupportChat {
3037 #[serde(rename = "chatTs")]
3038 pub chat_ts: UtcTime,
3039
3040 #[serde(rename = "unread", deserialize_with = "deserialize_number_from_string")]
3041 pub unread: i64,
3042
3043 #[serde(
3044 rename = "memberAttention",
3045 deserialize_with = "deserialize_number_from_string"
3046 )]
3047 pub member_attention: i64,
3048
3049 #[serde(
3050 rename = "mentions",
3051 deserialize_with = "deserialize_number_from_string"
3052 )]
3053 pub mentions: i64,
3054
3055 #[serde(
3056 rename = "lastMsgFromMemberTs",
3057 skip_serializing_if = "Option::is_none"
3058 )]
3059 pub last_msg_from_member_ts: Option<UtcTime>,
3060
3061 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3062 #[cfg_attr(feature = "bon", builder(default))]
3063 pub undocumented: BTreeMap<String, JsonObject>,
3064}
3065
3066#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
3067#[non_exhaustive]
3068pub enum InlineFileMode {
3069 #[default]
3070 #[serde(rename = "offer")]
3071 Offer,
3072 #[serde(rename = "sent")]
3073 Sent,
3074}
3075
3076#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3077#[serde(tag = "type")]
3078#[non_exhaustive]
3079pub enum InvitationLinkPlan {
3080 #[serde(rename = "ok")]
3081 Ok {
3082 #[serde(rename = "contactSLinkData_", skip_serializing_if = "Option::is_none")]
3083 contact_s_link_data: Option<ContactShortLinkData>,
3084
3085 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3086 undocumented: BTreeMap<String, JsonObject>,
3087 },
3088 #[serde(rename = "ownLink")]
3089 OwnLink,
3090 #[serde(rename = "connecting")]
3091 Connecting {
3092 #[serde(rename = "contact_", skip_serializing_if = "Option::is_none")]
3093 contact: Option<Contact>,
3094
3095 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3096 undocumented: BTreeMap<String, JsonObject>,
3097 },
3098 #[serde(rename = "known")]
3099 Known {
3100 #[serde(rename = "contact")]
3101 contact: Contact,
3102
3103 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3104 undocumented: BTreeMap<String, JsonObject>,
3105 },
3106 #[serde(untagged)]
3107 Undocumented(BTreeMap<String, JsonObject>),
3108}
3109
3110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3111#[serde(tag = "type")]
3112#[non_exhaustive]
3113pub enum InvitedBy {
3114 #[serde(rename = "contact")]
3115 Contact {
3116 #[serde(
3117 rename = "byContactId",
3118 deserialize_with = "deserialize_number_from_string"
3119 )]
3120 by_contact_id: i64,
3121
3122 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3123 undocumented: BTreeMap<String, JsonObject>,
3124 },
3125 #[serde(rename = "user")]
3126 User,
3127 #[serde(rename = "unknown")]
3128 Unknown,
3129 #[serde(untagged)]
3130 Undocumented(BTreeMap<String, JsonObject>),
3131}
3132
3133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3134#[serde(tag = "type")]
3135#[non_exhaustive]
3136pub enum LinkContent {
3137 #[serde(rename = "page")]
3138 Page,
3139 #[serde(rename = "image")]
3140 Image,
3141 #[serde(rename = "video")]
3142 Video {
3143 #[serde(
3144 rename = "duration",
3145 skip_serializing_if = "Option::is_none",
3146 deserialize_with = "deserialize_option_number_from_string",
3147 default
3148 )]
3149 duration: Option<i32>,
3150
3151 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3152 undocumented: BTreeMap<String, JsonObject>,
3153 },
3154 #[serde(rename = "unknown")]
3155 Unknown {
3156 #[serde(rename = "tag")]
3157 tag: String,
3158
3159 #[serde(rename = "json")]
3160 json: JsonObject,
3161
3162 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3163 undocumented: BTreeMap<String, JsonObject>,
3164 },
3165 #[serde(untagged)]
3166 Undocumented(BTreeMap<String, JsonObject>),
3167}
3168
3169#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3170#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3171#[cfg_attr(feature = "bon", builder(on(String, into)))]
3172pub struct LinkPreview {
3173 #[serde(rename = "uri")]
3174 pub uri: String,
3175
3176 #[serde(rename = "title")]
3177 pub title: String,
3178
3179 #[serde(rename = "description")]
3180 pub description: String,
3181
3182 #[serde(rename = "image")]
3183 pub image: String,
3184
3185 #[serde(rename = "content", skip_serializing_if = "Option::is_none")]
3186 pub content: Option<LinkContent>,
3187
3188 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3189 #[cfg_attr(feature = "bon", builder(default))]
3190 pub undocumented: BTreeMap<String, JsonObject>,
3191}
3192
3193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3194#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3195#[cfg_attr(feature = "bon", builder(on(String, into)))]
3196pub struct LocalProfile {
3197 #[serde(
3198 rename = "profileId",
3199 deserialize_with = "deserialize_number_from_string"
3200 )]
3201 pub profile_id: i64,
3202
3203 #[serde(rename = "displayName")]
3204 pub display_name: String,
3205
3206 #[serde(rename = "fullName")]
3207 pub full_name: String,
3208
3209 #[serde(rename = "shortDescr", skip_serializing_if = "Option::is_none")]
3210 pub short_descr: Option<String>,
3211
3212 #[serde(rename = "image", skip_serializing_if = "Option::is_none")]
3213 pub image: Option<String>,
3214
3215 #[serde(rename = "contactLink", skip_serializing_if = "Option::is_none")]
3216 pub contact_link: Option<String>,
3217
3218 #[serde(rename = "preferences", skip_serializing_if = "Option::is_none")]
3219 pub preferences: Option<Preferences>,
3220
3221 #[serde(rename = "peerType", skip_serializing_if = "Option::is_none")]
3222 pub peer_type: Option<ChatPeerType>,
3223
3224 #[serde(rename = "localAlias")]
3225 pub local_alias: String,
3226
3227 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3228 #[cfg_attr(feature = "bon", builder(default))]
3229 pub undocumented: BTreeMap<String, JsonObject>,
3230}
3231
3232#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
3233#[non_exhaustive]
3234pub enum MemberCriteria {
3235 #[default]
3236 #[serde(rename = "all")]
3237 All,
3238}
3239
3240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3242#[serde(tag = "type")]
3243#[non_exhaustive]
3244pub enum MsgChatLink {
3245 #[serde(rename = "contact")]
3246 Contact {
3247 #[serde(rename = "connLink")]
3248 conn_link: String,
3249
3250 #[serde(rename = "profile")]
3251 profile: Profile,
3252
3253 #[serde(rename = "business")]
3254 business: bool,
3255
3256 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3257 undocumented: BTreeMap<String, JsonObject>,
3258 },
3259 #[serde(rename = "invitation")]
3260 Invitation {
3261 #[serde(rename = "invLink")]
3262 inv_link: String,
3263
3264 #[serde(rename = "profile")]
3265 profile: Profile,
3266
3267 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3268 undocumented: BTreeMap<String, JsonObject>,
3269 },
3270 #[serde(rename = "group")]
3271 Group {
3272 #[serde(rename = "connLink")]
3273 conn_link: String,
3274
3275 #[serde(rename = "groupProfile")]
3276 group_profile: GroupProfile,
3277
3278 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3279 undocumented: BTreeMap<String, JsonObject>,
3280 },
3281 #[serde(untagged)]
3282 Undocumented(BTreeMap<String, JsonObject>),
3283}
3284
3285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3286#[serde(tag = "type")]
3287#[non_exhaustive]
3288pub enum MsgContent {
3289 #[serde(rename = "text")]
3290 Text {
3291 #[serde(rename = "text")]
3292 text: String,
3293
3294 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3295 undocumented: BTreeMap<String, JsonObject>,
3296 },
3297 #[serde(rename = "link")]
3298 Link {
3299 #[serde(rename = "text")]
3300 text: String,
3301
3302 #[serde(rename = "preview")]
3303 preview: LinkPreview,
3304
3305 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3306 undocumented: BTreeMap<String, JsonObject>,
3307 },
3308 #[serde(rename = "image")]
3309 Image {
3310 #[serde(rename = "text")]
3311 text: String,
3312
3313 #[serde(rename = "image")]
3314 image: String,
3315
3316 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3317 undocumented: BTreeMap<String, JsonObject>,
3318 },
3319 #[serde(rename = "video")]
3320 Video {
3321 #[serde(rename = "text")]
3322 text: String,
3323
3324 #[serde(rename = "image")]
3325 image: String,
3326
3327 #[serde(
3328 rename = "duration",
3329 deserialize_with = "deserialize_number_from_string"
3330 )]
3331 duration: i32,
3332
3333 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3334 undocumented: BTreeMap<String, JsonObject>,
3335 },
3336 #[serde(rename = "voice")]
3337 Voice {
3338 #[serde(rename = "text")]
3339 text: String,
3340
3341 #[serde(
3342 rename = "duration",
3343 deserialize_with = "deserialize_number_from_string"
3344 )]
3345 duration: i32,
3346
3347 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3348 undocumented: BTreeMap<String, JsonObject>,
3349 },
3350 #[serde(rename = "file")]
3351 File {
3352 #[serde(rename = "text")]
3353 text: String,
3354
3355 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3356 undocumented: BTreeMap<String, JsonObject>,
3357 },
3358 #[serde(rename = "report")]
3359 Report {
3360 #[serde(rename = "text")]
3361 text: String,
3362
3363 #[serde(rename = "reason")]
3364 reason: ReportReason,
3365
3366 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3367 undocumented: BTreeMap<String, JsonObject>,
3368 },
3369 #[serde(rename = "chat")]
3370 Chat {
3371 #[serde(rename = "text")]
3372 text: String,
3373
3374 #[serde(rename = "chatLink")]
3375 chat_link: MsgChatLink,
3376
3377 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3378 undocumented: BTreeMap<String, JsonObject>,
3379 },
3380 #[serde(rename = "unknown")]
3381 Unknown {
3382 #[serde(rename = "tag")]
3383 tag: String,
3384
3385 #[serde(rename = "text")]
3386 text: String,
3387
3388 #[serde(rename = "json")]
3389 json: JsonObject,
3390
3391 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3392 undocumented: BTreeMap<String, JsonObject>,
3393 },
3394 #[serde(untagged)]
3395 Undocumented(BTreeMap<String, JsonObject>),
3396}
3397
3398#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
3399#[non_exhaustive]
3400pub enum MsgDirection {
3401 #[default]
3402 #[serde(rename = "rcv")]
3403 Rcv,
3404 #[serde(rename = "snd")]
3405 Snd,
3406}
3407
3408#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
3409#[non_exhaustive]
3410pub enum MsgFilter {
3411 #[default]
3412 #[serde(rename = "none")]
3413 None,
3414 #[serde(rename = "all")]
3415 All,
3416 #[serde(rename = "mentions")]
3417 Mentions,
3418}
3419
3420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3421#[serde(tag = "type")]
3422#[non_exhaustive]
3423pub enum MsgReaction {
3424 #[serde(rename = "emoji")]
3425 Emoji {
3426 #[serde(rename = "emoji")]
3427 emoji: String,
3428
3429 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3430 undocumented: BTreeMap<String, JsonObject>,
3431 },
3432 #[serde(rename = "unknown")]
3433 Unknown {
3434 #[serde(rename = "tag")]
3435 tag: String,
3436
3437 #[serde(rename = "json")]
3438 json: JsonObject,
3439
3440 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3441 undocumented: BTreeMap<String, JsonObject>,
3442 },
3443 #[serde(untagged)]
3444 Undocumented(BTreeMap<String, JsonObject>),
3445}
3446
3447#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
3448#[non_exhaustive]
3449pub enum MsgReceiptStatus {
3450 #[default]
3451 #[serde(rename = "ok")]
3452 Ok,
3453 #[serde(rename = "badMsgHash")]
3454 BadMsgHash,
3455}
3456
3457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3458#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3459#[cfg_attr(feature = "bon", builder(on(String, into)))]
3460pub struct NewUser {
3461 #[serde(rename = "profile", skip_serializing_if = "Option::is_none")]
3462 pub profile: Option<Profile>,
3463
3464 #[serde(rename = "pastTimestamp")]
3465 pub past_timestamp: bool,
3466
3467 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3468 #[cfg_attr(feature = "bon", builder(default))]
3469 pub undocumented: BTreeMap<String, JsonObject>,
3470}
3471
3472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3473#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3474#[cfg_attr(feature = "bon", builder(on(String, into)))]
3475pub struct NoteFolder {
3476 #[serde(
3477 rename = "noteFolderId",
3478 deserialize_with = "deserialize_number_from_string"
3479 )]
3480 pub note_folder_id: i64,
3481
3482 #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
3483 pub user_id: i64,
3484
3485 #[serde(rename = "createdAt")]
3486 pub created_at: UtcTime,
3487
3488 #[serde(rename = "updatedAt")]
3489 pub updated_at: UtcTime,
3490
3491 #[serde(rename = "chatTs")]
3492 pub chat_ts: UtcTime,
3493
3494 #[serde(rename = "favorite")]
3495 pub favorite: bool,
3496
3497 #[serde(rename = "unread")]
3498 pub unread: bool,
3499
3500 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3501 #[cfg_attr(feature = "bon", builder(default))]
3502 pub undocumented: BTreeMap<String, JsonObject>,
3503}
3504
3505#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3506#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3507#[cfg_attr(feature = "bon", builder(on(String, into)))]
3508pub struct PendingContactConnection {
3509 #[serde(
3510 rename = "pccConnId",
3511 deserialize_with = "deserialize_number_from_string"
3512 )]
3513 pub pcc_conn_id: i64,
3514
3515 #[serde(rename = "pccAgentConnId")]
3516 pub pcc_agent_conn_id: String,
3517
3518 #[serde(rename = "pccConnStatus")]
3519 pub pcc_conn_status: ConnStatus,
3520
3521 #[serde(rename = "viaContactUri")]
3522 pub via_contact_uri: bool,
3523
3524 #[serde(
3525 rename = "viaUserContactLink",
3526 skip_serializing_if = "Option::is_none",
3527 deserialize_with = "deserialize_option_number_from_string",
3528 default
3529 )]
3530 pub via_user_contact_link: Option<i64>,
3531
3532 #[serde(rename = "groupLinkId", skip_serializing_if = "Option::is_none")]
3533 pub group_link_id: Option<String>,
3534
3535 #[serde(
3536 rename = "customUserProfileId",
3537 skip_serializing_if = "Option::is_none",
3538 deserialize_with = "deserialize_option_number_from_string",
3539 default
3540 )]
3541 pub custom_user_profile_id: Option<i64>,
3542
3543 #[serde(rename = "connLinkInv", skip_serializing_if = "Option::is_none")]
3544 pub conn_link_inv: Option<CreatedConnLink>,
3545
3546 #[serde(rename = "localAlias")]
3547 pub local_alias: String,
3548
3549 #[serde(rename = "createdAt")]
3550 pub created_at: UtcTime,
3551
3552 #[serde(rename = "updatedAt")]
3553 pub updated_at: UtcTime,
3554
3555 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3556 #[cfg_attr(feature = "bon", builder(default))]
3557 pub undocumented: BTreeMap<String, JsonObject>,
3558}
3559
3560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3561#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3562#[cfg_attr(feature = "bon", builder(on(String, into)))]
3563pub struct PrefEnabled {
3564 #[serde(rename = "forUser")]
3565 pub for_user: bool,
3566
3567 #[serde(rename = "forContact")]
3568 pub for_contact: bool,
3569
3570 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3571 #[cfg_attr(feature = "bon", builder(default))]
3572 pub undocumented: BTreeMap<String, JsonObject>,
3573}
3574
3575#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3576#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3577#[cfg_attr(feature = "bon", builder(on(String, into)))]
3578pub struct Preferences {
3579 #[serde(rename = "timedMessages", skip_serializing_if = "Option::is_none")]
3580 pub timed_messages: Option<TimedMessagesPreference>,
3581
3582 #[serde(rename = "fullDelete", skip_serializing_if = "Option::is_none")]
3583 pub full_delete: Option<SimplePreference>,
3584
3585 #[serde(rename = "reactions", skip_serializing_if = "Option::is_none")]
3586 pub reactions: Option<SimplePreference>,
3587
3588 #[serde(rename = "voice", skip_serializing_if = "Option::is_none")]
3589 pub voice: Option<SimplePreference>,
3590
3591 #[serde(rename = "files", skip_serializing_if = "Option::is_none")]
3592 pub files: Option<SimplePreference>,
3593
3594 #[serde(rename = "calls", skip_serializing_if = "Option::is_none")]
3595 pub calls: Option<SimplePreference>,
3596
3597 #[serde(rename = "sessions", skip_serializing_if = "Option::is_none")]
3598 pub sessions: Option<SimplePreference>,
3599
3600 #[serde(rename = "commands", skip_serializing_if = "Option::is_none")]
3601 pub commands: Option<Vec<ChatBotCommand>>,
3602
3603 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3604 #[cfg_attr(feature = "bon", builder(default))]
3605 pub undocumented: BTreeMap<String, JsonObject>,
3606}
3607
3608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3609#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3610#[cfg_attr(feature = "bon", builder(on(String, into)))]
3611pub struct PreparedContact {
3612 #[serde(rename = "connLinkToConnect")]
3613 pub conn_link_to_connect: CreatedConnLink,
3614
3615 #[serde(rename = "uiConnLinkType")]
3616 pub ui_conn_link_type: ConnectionMode,
3617
3618 #[serde(rename = "welcomeSharedMsgId", skip_serializing_if = "Option::is_none")]
3619 pub welcome_shared_msg_id: Option<String>,
3620
3621 #[serde(rename = "requestSharedMsgId", skip_serializing_if = "Option::is_none")]
3622 pub request_shared_msg_id: Option<String>,
3623
3624 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3625 #[cfg_attr(feature = "bon", builder(default))]
3626 pub undocumented: BTreeMap<String, JsonObject>,
3627}
3628
3629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3630#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3631#[cfg_attr(feature = "bon", builder(on(String, into)))]
3632pub struct PreparedGroup {
3633 #[serde(rename = "connLinkToConnect")]
3634 pub conn_link_to_connect: CreatedConnLink,
3635
3636 #[serde(rename = "connLinkPreparedConnection")]
3637 pub conn_link_prepared_connection: bool,
3638
3639 #[serde(rename = "connLinkStartedConnection")]
3640 pub conn_link_started_connection: bool,
3641
3642 #[serde(rename = "welcomeSharedMsgId", skip_serializing_if = "Option::is_none")]
3643 pub welcome_shared_msg_id: Option<String>,
3644
3645 #[serde(rename = "requestSharedMsgId", skip_serializing_if = "Option::is_none")]
3646 pub request_shared_msg_id: Option<String>,
3647
3648 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3649 #[cfg_attr(feature = "bon", builder(default))]
3650 pub undocumented: BTreeMap<String, JsonObject>,
3651}
3652
3653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3654#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3655#[cfg_attr(feature = "bon", builder(on(String, into)))]
3656pub struct Profile {
3657 #[serde(rename = "displayName")]
3658 pub display_name: String,
3659
3660 #[serde(rename = "fullName")]
3661 pub full_name: String,
3662
3663 #[serde(rename = "shortDescr", skip_serializing_if = "Option::is_none")]
3664 pub short_descr: Option<String>,
3665
3666 #[serde(rename = "image", skip_serializing_if = "Option::is_none")]
3667 pub image: Option<String>,
3668
3669 #[serde(rename = "contactLink", skip_serializing_if = "Option::is_none")]
3670 pub contact_link: Option<String>,
3671
3672 #[serde(rename = "preferences", skip_serializing_if = "Option::is_none")]
3673 pub preferences: Option<Preferences>,
3674
3675 #[serde(rename = "peerType", skip_serializing_if = "Option::is_none")]
3676 pub peer_type: Option<ChatPeerType>,
3677
3678 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3679 #[cfg_attr(feature = "bon", builder(default))]
3680 pub undocumented: BTreeMap<String, JsonObject>,
3681}
3682
3683#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
3684#[non_exhaustive]
3685pub enum RatchetSyncState {
3686 #[default]
3687 #[serde(rename = "ok")]
3688 Ok,
3689 #[serde(rename = "allowed")]
3690 Allowed,
3691 #[serde(rename = "required")]
3692 Required,
3693 #[serde(rename = "started")]
3694 Started,
3695 #[serde(rename = "agreed")]
3696 Agreed,
3697}
3698
3699#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3700#[serde(tag = "type")]
3701#[non_exhaustive]
3702pub enum RcvConnEvent {
3703 #[serde(rename = "switchQueue")]
3704 SwitchQueue {
3705 #[serde(rename = "phase")]
3706 phase: SwitchPhase,
3707
3708 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3709 undocumented: BTreeMap<String, JsonObject>,
3710 },
3711 #[serde(rename = "ratchetSync")]
3712 RatchetSync {
3713 #[serde(rename = "syncStatus")]
3714 sync_status: RatchetSyncState,
3715
3716 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3717 undocumented: BTreeMap<String, JsonObject>,
3718 },
3719 #[serde(rename = "verificationCodeReset")]
3720 VerificationCodeReset,
3721 #[serde(rename = "pqEnabled")]
3722 PqEnabled {
3723 #[serde(rename = "enabled")]
3724 enabled: bool,
3725
3726 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3727 undocumented: BTreeMap<String, JsonObject>,
3728 },
3729 #[serde(untagged)]
3730 Undocumented(BTreeMap<String, JsonObject>),
3731}
3732
3733#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3734#[serde(tag = "type")]
3735#[non_exhaustive]
3736pub enum RcvDirectEvent {
3737 #[serde(rename = "contactDeleted")]
3738 ContactDeleted,
3739 #[serde(rename = "profileUpdated")]
3740 ProfileUpdated {
3741 #[serde(rename = "fromProfile")]
3742 from_profile: Profile,
3743
3744 #[serde(rename = "toProfile")]
3745 to_profile: Profile,
3746
3747 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3748 undocumented: BTreeMap<String, JsonObject>,
3749 },
3750 #[serde(rename = "groupInvLinkReceived")]
3751 GroupInvLinkReceived {
3752 #[serde(rename = "groupProfile")]
3753 group_profile: GroupProfile,
3754
3755 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3756 undocumented: BTreeMap<String, JsonObject>,
3757 },
3758 #[serde(untagged)]
3759 Undocumented(BTreeMap<String, JsonObject>),
3760}
3761
3762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3763#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3764#[cfg_attr(feature = "bon", builder(on(String, into)))]
3765pub struct RcvFileDescr {
3766 #[serde(
3767 rename = "fileDescrId",
3768 deserialize_with = "deserialize_number_from_string"
3769 )]
3770 pub file_descr_id: i64,
3771
3772 #[serde(rename = "fileDescrText")]
3773 pub file_descr_text: String,
3774
3775 #[serde(
3776 rename = "fileDescrPartNo",
3777 deserialize_with = "deserialize_number_from_string"
3778 )]
3779 pub file_descr_part_no: i32,
3780
3781 #[serde(rename = "fileDescrComplete")]
3782 pub file_descr_complete: bool,
3783
3784 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3785 #[cfg_attr(feature = "bon", builder(default))]
3786 pub undocumented: BTreeMap<String, JsonObject>,
3787}
3788
3789#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3790#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3791#[cfg_attr(feature = "bon", builder(on(String, into)))]
3792pub struct RcvFileInfo {
3793 #[serde(rename = "filePath")]
3794 pub file_path: String,
3795
3796 #[serde(
3797 rename = "connId",
3798 skip_serializing_if = "Option::is_none",
3799 deserialize_with = "deserialize_option_number_from_string",
3800 default
3801 )]
3802 pub conn_id: Option<i64>,
3803
3804 #[serde(rename = "agentConnId", skip_serializing_if = "Option::is_none")]
3805 pub agent_conn_id: Option<String>,
3806
3807 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3808 #[cfg_attr(feature = "bon", builder(default))]
3809 pub undocumented: BTreeMap<String, JsonObject>,
3810}
3811
3812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3813#[serde(tag = "type")]
3814#[non_exhaustive]
3815pub enum RcvFileStatus {
3816 #[serde(rename = "new")]
3817 New,
3818 #[serde(rename = "accepted")]
3819 Accepted {
3820 #[serde(rename = "fileInfo")]
3821 file_info: RcvFileInfo,
3822
3823 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3824 undocumented: BTreeMap<String, JsonObject>,
3825 },
3826 #[serde(rename = "connected")]
3827 Connected {
3828 #[serde(rename = "fileInfo")]
3829 file_info: RcvFileInfo,
3830
3831 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3832 undocumented: BTreeMap<String, JsonObject>,
3833 },
3834 #[serde(rename = "complete")]
3835 Complete {
3836 #[serde(rename = "fileInfo")]
3837 file_info: RcvFileInfo,
3838
3839 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3840 undocumented: BTreeMap<String, JsonObject>,
3841 },
3842 #[serde(rename = "cancelled")]
3843 Cancelled {
3844 #[serde(rename = "fileInfo_", skip_serializing_if = "Option::is_none")]
3845 file_info: Option<RcvFileInfo>,
3846
3847 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3848 undocumented: BTreeMap<String, JsonObject>,
3849 },
3850 #[serde(untagged)]
3851 Undocumented(BTreeMap<String, JsonObject>),
3852}
3853
3854#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3855#[cfg_attr(feature = "bon", derive(::bon::Builder))]
3856#[cfg_attr(feature = "bon", builder(on(String, into)))]
3857pub struct RcvFileTransfer {
3858 #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3859 pub file_id: i64,
3860
3861 #[serde(rename = "xftpRcvFile", skip_serializing_if = "Option::is_none")]
3862 pub xftp_rcv_file: Option<XFTPRcvFile>,
3863
3864 #[serde(rename = "fileInvitation")]
3865 pub file_invitation: FileInvitation,
3866
3867 #[serde(rename = "fileStatus")]
3868 pub file_status: RcvFileStatus,
3869
3870 #[serde(rename = "rcvFileInline", skip_serializing_if = "Option::is_none")]
3871 pub rcv_file_inline: Option<InlineFileMode>,
3872
3873 #[serde(rename = "senderDisplayName")]
3874 pub sender_display_name: String,
3875
3876 #[serde(
3877 rename = "chunkSize",
3878 deserialize_with = "deserialize_number_from_string"
3879 )]
3880 pub chunk_size: i64,
3881
3882 #[serde(rename = "cancelled")]
3883 pub cancelled: bool,
3884
3885 #[serde(
3886 rename = "grpMemberId",
3887 skip_serializing_if = "Option::is_none",
3888 deserialize_with = "deserialize_option_number_from_string",
3889 default
3890 )]
3891 pub grp_member_id: Option<i64>,
3892
3893 #[serde(rename = "cryptoArgs", skip_serializing_if = "Option::is_none")]
3894 pub crypto_args: Option<CryptoFileArgs>,
3895
3896 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3897 #[cfg_attr(feature = "bon", builder(default))]
3898 pub undocumented: BTreeMap<String, JsonObject>,
3899}
3900
3901#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3902#[serde(tag = "type")]
3903#[non_exhaustive]
3904pub enum RcvGroupEvent {
3905 #[serde(rename = "memberAdded")]
3906 MemberAdded {
3907 #[serde(
3908 rename = "groupMemberId",
3909 deserialize_with = "deserialize_number_from_string"
3910 )]
3911 group_member_id: i64,
3912
3913 #[serde(rename = "profile")]
3914 profile: Profile,
3915
3916 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3917 undocumented: BTreeMap<String, JsonObject>,
3918 },
3919 #[serde(rename = "memberConnected")]
3920 MemberConnected,
3921 #[serde(rename = "memberAccepted")]
3922 MemberAccepted {
3923 #[serde(
3924 rename = "groupMemberId",
3925 deserialize_with = "deserialize_number_from_string"
3926 )]
3927 group_member_id: i64,
3928
3929 #[serde(rename = "profile")]
3930 profile: Profile,
3931
3932 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3933 undocumented: BTreeMap<String, JsonObject>,
3934 },
3935 #[serde(rename = "userAccepted")]
3936 UserAccepted,
3937 #[serde(rename = "memberLeft")]
3938 MemberLeft,
3939 #[serde(rename = "memberRole")]
3940 MemberRole {
3941 #[serde(
3942 rename = "groupMemberId",
3943 deserialize_with = "deserialize_number_from_string"
3944 )]
3945 group_member_id: i64,
3946
3947 #[serde(rename = "profile")]
3948 profile: Profile,
3949
3950 #[serde(rename = "role")]
3951 role: GroupMemberRole,
3952
3953 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3954 undocumented: BTreeMap<String, JsonObject>,
3955 },
3956 #[serde(rename = "memberBlocked")]
3957 MemberBlocked {
3958 #[serde(
3959 rename = "groupMemberId",
3960 deserialize_with = "deserialize_number_from_string"
3961 )]
3962 group_member_id: i64,
3963
3964 #[serde(rename = "profile")]
3965 profile: Profile,
3966
3967 #[serde(rename = "blocked")]
3968 blocked: bool,
3969
3970 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3971 undocumented: BTreeMap<String, JsonObject>,
3972 },
3973 #[serde(rename = "userRole")]
3974 UserRole {
3975 #[serde(rename = "role")]
3976 role: GroupMemberRole,
3977
3978 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3979 undocumented: BTreeMap<String, JsonObject>,
3980 },
3981 #[serde(rename = "memberDeleted")]
3982 MemberDeleted {
3983 #[serde(
3984 rename = "groupMemberId",
3985 deserialize_with = "deserialize_number_from_string"
3986 )]
3987 group_member_id: i64,
3988
3989 #[serde(rename = "profile")]
3990 profile: Profile,
3991
3992 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
3993 undocumented: BTreeMap<String, JsonObject>,
3994 },
3995 #[serde(rename = "userDeleted")]
3996 UserDeleted,
3997 #[serde(rename = "groupDeleted")]
3998 GroupDeleted,
3999 #[serde(rename = "groupUpdated")]
4000 GroupUpdated {
4001 #[serde(rename = "groupProfile")]
4002 group_profile: GroupProfile,
4003
4004 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4005 undocumented: BTreeMap<String, JsonObject>,
4006 },
4007 #[serde(rename = "invitedViaGroupLink")]
4008 InvitedViaGroupLink,
4009 #[serde(rename = "memberCreatedContact")]
4010 MemberCreatedContact,
4011 #[serde(rename = "memberProfileUpdated")]
4012 MemberProfileUpdated {
4013 #[serde(rename = "fromProfile")]
4014 from_profile: Profile,
4015
4016 #[serde(rename = "toProfile")]
4017 to_profile: Profile,
4018
4019 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4020 undocumented: BTreeMap<String, JsonObject>,
4021 },
4022 #[serde(rename = "newMemberPendingReview")]
4023 NewMemberPendingReview,
4024 #[serde(untagged)]
4025 Undocumented(BTreeMap<String, JsonObject>),
4026}
4027
4028#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
4029#[non_exhaustive]
4030pub enum ReportReason {
4031 #[default]
4032 #[serde(rename = "spam")]
4033 Spam,
4034 #[serde(rename = "content")]
4035 Content,
4036 #[serde(rename = "community")]
4037 Community,
4038 #[serde(rename = "profile")]
4039 Profile,
4040 #[serde(rename = "other")]
4041 Other,
4042}
4043
4044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4045#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4046#[cfg_attr(feature = "bon", builder(on(String, into)))]
4047pub struct RoleGroupPreference {
4048 #[serde(rename = "enable")]
4049 pub enable: GroupFeatureEnabled,
4050
4051 #[serde(rename = "role", skip_serializing_if = "Option::is_none")]
4052 pub role: Option<GroupMemberRole>,
4053
4054 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4055 #[cfg_attr(feature = "bon", builder(default))]
4056 pub undocumented: BTreeMap<String, JsonObject>,
4057}
4058
4059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4060#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4061#[cfg_attr(feature = "bon", builder(on(String, into)))]
4062pub struct SecurityCode {
4063 #[serde(rename = "securityCode")]
4064 pub security_code: String,
4065
4066 #[serde(rename = "verifiedAt")]
4067 pub verified_at: UtcTime,
4068
4069 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4070 #[cfg_attr(feature = "bon", builder(default))]
4071 pub undocumented: BTreeMap<String, JsonObject>,
4072}
4073
4074#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4075#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4076#[cfg_attr(feature = "bon", builder(on(String, into)))]
4077pub struct SimplePreference {
4078 #[serde(rename = "allow")]
4079 pub allow: FeatureAllowed,
4080
4081 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4082 #[cfg_attr(feature = "bon", builder(default))]
4083 pub undocumented: BTreeMap<String, JsonObject>,
4084}
4085
4086#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
4087#[non_exhaustive]
4088pub enum SimplexLinkType {
4089 #[default]
4090 #[serde(rename = "contact")]
4091 Contact,
4092 #[serde(rename = "invitation")]
4093 Invitation,
4094 #[serde(rename = "group")]
4095 Group,
4096 #[serde(rename = "channel")]
4097 Channel,
4098 #[serde(rename = "relay")]
4099 Relay,
4100}
4101
4102#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
4103#[non_exhaustive]
4104pub enum SndCIStatusProgress {
4105 #[default]
4106 #[serde(rename = "partial")]
4107 Partial,
4108 #[serde(rename = "complete")]
4109 Complete,
4110}
4111
4112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4113#[serde(tag = "type")]
4114#[non_exhaustive]
4115pub enum SndConnEvent {
4116 #[serde(rename = "switchQueue")]
4117 SwitchQueue {
4118 #[serde(rename = "phase")]
4119 phase: SwitchPhase,
4120
4121 #[serde(rename = "member", skip_serializing_if = "Option::is_none")]
4122 member: Option<GroupMemberRef>,
4123
4124 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4125 undocumented: BTreeMap<String, JsonObject>,
4126 },
4127 #[serde(rename = "ratchetSync")]
4128 RatchetSync {
4129 #[serde(rename = "syncStatus")]
4130 sync_status: RatchetSyncState,
4131
4132 #[serde(rename = "member", skip_serializing_if = "Option::is_none")]
4133 member: Option<GroupMemberRef>,
4134
4135 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4136 undocumented: BTreeMap<String, JsonObject>,
4137 },
4138 #[serde(rename = "pqEnabled")]
4139 PqEnabled {
4140 #[serde(rename = "enabled")]
4141 enabled: bool,
4142
4143 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4144 undocumented: BTreeMap<String, JsonObject>,
4145 },
4146 #[serde(untagged)]
4147 Undocumented(BTreeMap<String, JsonObject>),
4148}
4149
4150#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4151#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4152#[cfg_attr(feature = "bon", builder(on(String, into)))]
4153pub struct SndFileTransfer {
4154 #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
4155 pub file_id: i64,
4156
4157 #[serde(rename = "fileName")]
4158 pub file_name: String,
4159
4160 #[serde(rename = "filePath")]
4161 pub file_path: String,
4162
4163 #[serde(
4164 rename = "fileSize",
4165 deserialize_with = "deserialize_number_from_string"
4166 )]
4167 pub file_size: i64,
4168
4169 #[serde(
4170 rename = "chunkSize",
4171 deserialize_with = "deserialize_number_from_string"
4172 )]
4173 pub chunk_size: i64,
4174
4175 #[serde(rename = "recipientDisplayName")]
4176 pub recipient_display_name: String,
4177
4178 #[serde(rename = "connId", deserialize_with = "deserialize_number_from_string")]
4179 pub conn_id: i64,
4180
4181 #[serde(rename = "agentConnId")]
4182 pub agent_conn_id: String,
4183
4184 #[serde(
4185 rename = "groupMemberId",
4186 skip_serializing_if = "Option::is_none",
4187 deserialize_with = "deserialize_option_number_from_string",
4188 default
4189 )]
4190 pub group_member_id: Option<i64>,
4191
4192 #[serde(rename = "fileStatus")]
4193 pub file_status: FileStatus,
4194
4195 #[serde(
4196 rename = "fileDescrId",
4197 skip_serializing_if = "Option::is_none",
4198 deserialize_with = "deserialize_option_number_from_string",
4199 default
4200 )]
4201 pub file_descr_id: Option<i64>,
4202
4203 #[serde(rename = "fileInline", skip_serializing_if = "Option::is_none")]
4204 pub file_inline: Option<InlineFileMode>,
4205
4206 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4207 #[cfg_attr(feature = "bon", builder(default))]
4208 pub undocumented: BTreeMap<String, JsonObject>,
4209}
4210
4211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4212#[serde(tag = "type")]
4213#[non_exhaustive]
4214pub enum SndGroupEvent {
4215 #[serde(rename = "memberRole")]
4216 MemberRole {
4217 #[serde(
4218 rename = "groupMemberId",
4219 deserialize_with = "deserialize_number_from_string"
4220 )]
4221 group_member_id: i64,
4222
4223 #[serde(rename = "profile")]
4224 profile: Profile,
4225
4226 #[serde(rename = "role")]
4227 role: GroupMemberRole,
4228
4229 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4230 undocumented: BTreeMap<String, JsonObject>,
4231 },
4232 #[serde(rename = "memberBlocked")]
4233 MemberBlocked {
4234 #[serde(
4235 rename = "groupMemberId",
4236 deserialize_with = "deserialize_number_from_string"
4237 )]
4238 group_member_id: i64,
4239
4240 #[serde(rename = "profile")]
4241 profile: Profile,
4242
4243 #[serde(rename = "blocked")]
4244 blocked: bool,
4245
4246 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4247 undocumented: BTreeMap<String, JsonObject>,
4248 },
4249 #[serde(rename = "userRole")]
4250 UserRole {
4251 #[serde(rename = "role")]
4252 role: GroupMemberRole,
4253
4254 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4255 undocumented: BTreeMap<String, JsonObject>,
4256 },
4257 #[serde(rename = "memberDeleted")]
4258 MemberDeleted {
4259 #[serde(
4260 rename = "groupMemberId",
4261 deserialize_with = "deserialize_number_from_string"
4262 )]
4263 group_member_id: i64,
4264
4265 #[serde(rename = "profile")]
4266 profile: Profile,
4267
4268 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4269 undocumented: BTreeMap<String, JsonObject>,
4270 },
4271 #[serde(rename = "userLeft")]
4272 UserLeft,
4273 #[serde(rename = "groupUpdated")]
4274 GroupUpdated {
4275 #[serde(rename = "groupProfile")]
4276 group_profile: GroupProfile,
4277
4278 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4279 undocumented: BTreeMap<String, JsonObject>,
4280 },
4281 #[serde(rename = "memberAccepted")]
4282 MemberAccepted {
4283 #[serde(
4284 rename = "groupMemberId",
4285 deserialize_with = "deserialize_number_from_string"
4286 )]
4287 group_member_id: i64,
4288
4289 #[serde(rename = "profile")]
4290 profile: Profile,
4291
4292 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4293 undocumented: BTreeMap<String, JsonObject>,
4294 },
4295 #[serde(rename = "userPendingReview")]
4296 UserPendingReview,
4297 #[serde(untagged)]
4298 Undocumented(BTreeMap<String, JsonObject>),
4299}
4300
4301#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
4302#[non_exhaustive]
4303pub enum SwitchPhase {
4304 #[default]
4305 #[serde(rename = "started")]
4306 Started,
4307 #[serde(rename = "confirmed")]
4308 Confirmed,
4309 #[serde(rename = "secured")]
4310 Secured,
4311 #[serde(rename = "completed")]
4312 Completed,
4313}
4314
4315#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4316#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4317#[cfg_attr(feature = "bon", builder(on(String, into)))]
4318pub struct TimedMessagesGroupPreference {
4319 #[serde(rename = "enable")]
4320 pub enable: GroupFeatureEnabled,
4321
4322 #[serde(
4323 rename = "ttl",
4324 skip_serializing_if = "Option::is_none",
4325 deserialize_with = "deserialize_option_number_from_string",
4326 default
4327 )]
4328 pub ttl: Option<i32>,
4329
4330 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4331 #[cfg_attr(feature = "bon", builder(default))]
4332 pub undocumented: BTreeMap<String, JsonObject>,
4333}
4334
4335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4336#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4337#[cfg_attr(feature = "bon", builder(on(String, into)))]
4338pub struct TimedMessagesPreference {
4339 #[serde(rename = "allow")]
4340 pub allow: FeatureAllowed,
4341
4342 #[serde(
4343 rename = "ttl",
4344 skip_serializing_if = "Option::is_none",
4345 deserialize_with = "deserialize_option_number_from_string",
4346 default
4347 )]
4348 pub ttl: Option<i32>,
4349
4350 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4351 #[cfg_attr(feature = "bon", builder(default))]
4352 pub undocumented: BTreeMap<String, JsonObject>,
4353}
4354
4355#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
4356#[non_exhaustive]
4357pub enum UIColorMode {
4358 #[default]
4359 #[serde(rename = "light")]
4360 Light,
4361 #[serde(rename = "dark")]
4362 Dark,
4363}
4364
4365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4366#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4367#[cfg_attr(feature = "bon", builder(on(String, into)))]
4368pub struct UIColors {
4369 #[serde(rename = "accent", skip_serializing_if = "Option::is_none")]
4370 pub accent: Option<String>,
4371
4372 #[serde(rename = "accentVariant", skip_serializing_if = "Option::is_none")]
4373 pub accent_variant: Option<String>,
4374
4375 #[serde(rename = "secondary", skip_serializing_if = "Option::is_none")]
4376 pub secondary: Option<String>,
4377
4378 #[serde(rename = "secondaryVariant", skip_serializing_if = "Option::is_none")]
4379 pub secondary_variant: Option<String>,
4380
4381 #[serde(rename = "background", skip_serializing_if = "Option::is_none")]
4382 pub background: Option<String>,
4383
4384 #[serde(rename = "menus", skip_serializing_if = "Option::is_none")]
4385 pub menus: Option<String>,
4386
4387 #[serde(rename = "title", skip_serializing_if = "Option::is_none")]
4388 pub title: Option<String>,
4389
4390 #[serde(rename = "accentVariant2", skip_serializing_if = "Option::is_none")]
4391 pub accent_variant_2: Option<String>,
4392
4393 #[serde(rename = "sentMessage", skip_serializing_if = "Option::is_none")]
4394 pub sent_message: Option<String>,
4395
4396 #[serde(rename = "sentReply", skip_serializing_if = "Option::is_none")]
4397 pub sent_reply: Option<String>,
4398
4399 #[serde(rename = "receivedMessage", skip_serializing_if = "Option::is_none")]
4400 pub received_message: Option<String>,
4401
4402 #[serde(rename = "receivedReply", skip_serializing_if = "Option::is_none")]
4403 pub received_reply: Option<String>,
4404
4405 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4406 #[cfg_attr(feature = "bon", builder(default))]
4407 pub undocumented: BTreeMap<String, JsonObject>,
4408}
4409
4410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4411#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4412#[cfg_attr(feature = "bon", builder(on(String, into)))]
4413pub struct UIThemeEntityOverride {
4414 #[serde(rename = "mode")]
4415 pub mode: UIColorMode,
4416
4417 #[serde(rename = "wallpaper", skip_serializing_if = "Option::is_none")]
4418 pub wallpaper: Option<ChatWallpaper>,
4419
4420 #[serde(rename = "colors")]
4421 pub colors: UIColors,
4422
4423 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4424 #[cfg_attr(feature = "bon", builder(default))]
4425 pub undocumented: BTreeMap<String, JsonObject>,
4426}
4427
4428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4429#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4430#[cfg_attr(feature = "bon", builder(on(String, into)))]
4431pub struct UIThemeEntityOverrides {
4432 #[serde(rename = "light", skip_serializing_if = "Option::is_none")]
4433 pub light: Option<UIThemeEntityOverride>,
4434
4435 #[serde(rename = "dark", skip_serializing_if = "Option::is_none")]
4436 pub dark: Option<UIThemeEntityOverride>,
4437
4438 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4439 #[cfg_attr(feature = "bon", builder(default))]
4440 pub undocumented: BTreeMap<String, JsonObject>,
4441}
4442
4443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4444#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4445#[cfg_attr(feature = "bon", builder(on(String, into)))]
4446pub struct UpdatedMessage {
4447 #[serde(rename = "msgContent")]
4448 pub msg_content: MsgContent,
4449
4450 #[serde(rename = "mentions")]
4451 pub mentions: HashMap<String, i64>,
4452
4453 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4454 #[cfg_attr(feature = "bon", builder(default))]
4455 pub undocumented: BTreeMap<String, JsonObject>,
4456}
4457
4458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4459#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4460#[cfg_attr(feature = "bon", builder(on(String, into)))]
4461pub struct User {
4462 #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
4463 pub user_id: i64,
4464
4465 #[serde(
4466 rename = "agentUserId",
4467 deserialize_with = "deserialize_number_from_string"
4468 )]
4469 pub agent_user_id: i64,
4470
4471 #[serde(
4472 rename = "userContactId",
4473 deserialize_with = "deserialize_number_from_string"
4474 )]
4475 pub user_contact_id: i64,
4476
4477 #[serde(rename = "localDisplayName")]
4478 pub local_display_name: String,
4479
4480 #[serde(rename = "profile")]
4481 pub profile: LocalProfile,
4482
4483 #[serde(rename = "fullPreferences")]
4484 pub full_preferences: FullPreferences,
4485
4486 #[serde(rename = "activeUser")]
4487 pub active_user: bool,
4488
4489 #[serde(
4490 rename = "activeOrder",
4491 deserialize_with = "deserialize_number_from_string"
4492 )]
4493 pub active_order: i64,
4494
4495 #[serde(rename = "viewPwdHash", skip_serializing_if = "Option::is_none")]
4496 pub view_pwd_hash: Option<UserPwdHash>,
4497
4498 #[serde(rename = "showNtfs")]
4499 pub show_ntfs: bool,
4500
4501 #[serde(rename = "sendRcptsContacts")]
4502 pub send_rcpts_contacts: bool,
4503
4504 #[serde(rename = "sendRcptsSmallGroups")]
4505 pub send_rcpts_small_groups: bool,
4506
4507 #[serde(rename = "autoAcceptMemberContacts")]
4508 pub auto_accept_member_contacts: bool,
4509
4510 #[serde(
4511 rename = "userMemberProfileUpdatedAt",
4512 skip_serializing_if = "Option::is_none"
4513 )]
4514 pub user_member_profile_updated_at: Option<UtcTime>,
4515
4516 #[serde(rename = "uiThemes", skip_serializing_if = "Option::is_none")]
4517 pub ui_themes: Option<UIThemeEntityOverrides>,
4518
4519 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4520 #[cfg_attr(feature = "bon", builder(default))]
4521 pub undocumented: BTreeMap<String, JsonObject>,
4522}
4523
4524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4525#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4526#[cfg_attr(feature = "bon", builder(on(String, into)))]
4527pub struct UserContact {
4528 #[serde(
4529 rename = "userContactLinkId",
4530 deserialize_with = "deserialize_number_from_string"
4531 )]
4532 pub user_contact_link_id: i64,
4533
4534 #[serde(rename = "connReqContact")]
4535 pub conn_req_contact: String,
4536
4537 #[serde(
4538 rename = "groupId",
4539 skip_serializing_if = "Option::is_none",
4540 deserialize_with = "deserialize_option_number_from_string",
4541 default
4542 )]
4543 pub group_id: Option<i64>,
4544
4545 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4546 #[cfg_attr(feature = "bon", builder(default))]
4547 pub undocumented: BTreeMap<String, JsonObject>,
4548}
4549
4550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4551#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4552#[cfg_attr(feature = "bon", builder(on(String, into)))]
4553pub struct UserContactLink {
4554 #[serde(
4555 rename = "userContactLinkId",
4556 deserialize_with = "deserialize_number_from_string"
4557 )]
4558 pub user_contact_link_id: i64,
4559
4560 #[serde(rename = "connLinkContact")]
4561 pub conn_link_contact: CreatedConnLink,
4562
4563 #[serde(rename = "shortLinkDataSet")]
4564 pub short_link_data_set: bool,
4565
4566 #[serde(rename = "shortLinkLargeDataSet")]
4567 pub short_link_large_data_set: bool,
4568
4569 #[serde(rename = "addressSettings")]
4570 pub address_settings: AddressSettings,
4571
4572 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4573 #[cfg_attr(feature = "bon", builder(default))]
4574 pub undocumented: BTreeMap<String, JsonObject>,
4575}
4576
4577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4578#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4579#[cfg_attr(feature = "bon", builder(on(String, into)))]
4580pub struct UserContactRequest {
4581 #[serde(
4582 rename = "contactRequestId",
4583 deserialize_with = "deserialize_number_from_string"
4584 )]
4585 pub contact_request_id: i64,
4586
4587 #[serde(rename = "agentInvitationId")]
4588 pub agent_invitation_id: String,
4589
4590 #[serde(
4591 rename = "contactId_",
4592 skip_serializing_if = "Option::is_none",
4593 deserialize_with = "deserialize_option_number_from_string",
4594 default
4595 )]
4596 pub contact_id: Option<i64>,
4597
4598 #[serde(
4599 rename = "businessGroupId_",
4600 skip_serializing_if = "Option::is_none",
4601 deserialize_with = "deserialize_option_number_from_string",
4602 default
4603 )]
4604 pub business_group_id: Option<i64>,
4605
4606 #[serde(
4607 rename = "userContactLinkId_",
4608 skip_serializing_if = "Option::is_none",
4609 deserialize_with = "deserialize_option_number_from_string",
4610 default
4611 )]
4612 pub user_contact_link_id: Option<i64>,
4613
4614 #[serde(rename = "cReqChatVRange")]
4615 pub c_req_chat_v_range: VersionRange,
4616
4617 #[serde(rename = "localDisplayName")]
4618 pub local_display_name: String,
4619
4620 #[serde(
4621 rename = "profileId",
4622 deserialize_with = "deserialize_number_from_string"
4623 )]
4624 pub profile_id: i64,
4625
4626 #[serde(rename = "profile")]
4627 pub profile: Profile,
4628
4629 #[serde(rename = "createdAt")]
4630 pub created_at: UtcTime,
4631
4632 #[serde(rename = "updatedAt")]
4633 pub updated_at: UtcTime,
4634
4635 #[serde(rename = "xContactId", skip_serializing_if = "Option::is_none")]
4636 pub x_contact_id: Option<String>,
4637
4638 #[serde(rename = "pqSupport")]
4639 pub pq_support: bool,
4640
4641 #[serde(rename = "welcomeSharedMsgId", skip_serializing_if = "Option::is_none")]
4642 pub welcome_shared_msg_id: Option<String>,
4643
4644 #[serde(rename = "requestSharedMsgId", skip_serializing_if = "Option::is_none")]
4645 pub request_shared_msg_id: Option<String>,
4646
4647 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4648 #[cfg_attr(feature = "bon", builder(default))]
4649 pub undocumented: BTreeMap<String, JsonObject>,
4650}
4651
4652#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4653#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4654#[cfg_attr(feature = "bon", builder(on(String, into)))]
4655pub struct UserInfo {
4656 #[serde(rename = "user")]
4657 pub user: User,
4658
4659 #[serde(
4660 rename = "unreadCount",
4661 deserialize_with = "deserialize_number_from_string"
4662 )]
4663 pub unread_count: i32,
4664
4665 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4666 #[cfg_attr(feature = "bon", builder(default))]
4667 pub undocumented: BTreeMap<String, JsonObject>,
4668}
4669
4670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4671#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4672#[cfg_attr(feature = "bon", builder(on(String, into)))]
4673pub struct UserProfileUpdateSummary {
4674 #[serde(
4675 rename = "updateSuccesses",
4676 deserialize_with = "deserialize_number_from_string"
4677 )]
4678 pub update_successes: i32,
4679
4680 #[serde(
4681 rename = "updateFailures",
4682 deserialize_with = "deserialize_number_from_string"
4683 )]
4684 pub update_failures: i32,
4685
4686 #[serde(rename = "changedContacts")]
4687 pub changed_contacts: Vec<Contact>,
4688
4689 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4690 #[cfg_attr(feature = "bon", builder(default))]
4691 pub undocumented: BTreeMap<String, JsonObject>,
4692}
4693
4694#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4695#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4696#[cfg_attr(feature = "bon", builder(on(String, into)))]
4697pub struct UserPwdHash {
4698 #[serde(rename = "hash")]
4699 pub hash: String,
4700
4701 #[serde(rename = "salt")]
4702 pub salt: String,
4703
4704 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4705 #[cfg_attr(feature = "bon", builder(default))]
4706 pub undocumented: BTreeMap<String, JsonObject>,
4707}
4708
4709#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4710#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4711#[cfg_attr(feature = "bon", builder(on(String, into)))]
4712pub struct VersionRange {
4713 #[serde(
4714 rename = "minVersion",
4715 deserialize_with = "deserialize_number_from_string"
4716 )]
4717 pub min_version: i32,
4718
4719 #[serde(
4720 rename = "maxVersion",
4721 deserialize_with = "deserialize_number_from_string"
4722 )]
4723 pub max_version: i32,
4724
4725 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4726 #[cfg_attr(feature = "bon", builder(default))]
4727 pub undocumented: BTreeMap<String, JsonObject>,
4728}
4729
4730#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4731#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4732#[cfg_attr(feature = "bon", builder(on(String, into)))]
4733pub struct XFTPRcvFile {
4734 #[serde(rename = "rcvFileDescription")]
4735 pub rcv_file_description: RcvFileDescr,
4736
4737 #[serde(rename = "agentRcvFileId", skip_serializing_if = "Option::is_none")]
4738 pub agent_rcv_file_id: Option<String>,
4739
4740 #[serde(rename = "agentRcvFileDeleted")]
4741 pub agent_rcv_file_deleted: bool,
4742
4743 #[serde(rename = "userApprovedRelays")]
4744 pub user_approved_relays: bool,
4745
4746 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4747 #[cfg_attr(feature = "bon", builder(default))]
4748 pub undocumented: BTreeMap<String, JsonObject>,
4749}
4750
4751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4752#[cfg_attr(feature = "bon", derive(::bon::Builder))]
4753#[cfg_attr(feature = "bon", builder(on(String, into)))]
4754pub struct XFTPSndFile {
4755 #[serde(rename = "agentSndFileId")]
4756 pub agent_snd_file_id: String,
4757
4758 #[serde(
4759 rename = "privateSndFileDescr",
4760 skip_serializing_if = "Option::is_none"
4761 )]
4762 pub private_snd_file_descr: Option<String>,
4763
4764 #[serde(rename = "agentSndFileDeleted")]
4765 pub agent_snd_file_deleted: bool,
4766
4767 #[serde(rename = "cryptoArgs", skip_serializing_if = "Option::is_none")]
4768 pub crypto_args: Option<CryptoFileArgs>,
4769
4770 #[serde(flatten, skip_serializing_if = "BTreeMap::is_empty")]
4771 #[cfg_attr(feature = "bon", builder(default))]
4772 pub undocumented: BTreeMap<String, JsonObject>,
4773}