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