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