Skip to main content

simploxide_api_types/
errors.rs

1use super::*;
2
3#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4#[serde(tag = "type")]
5#[non_exhaustive]
6pub enum AgentCryptoError {
7    #[serde(rename = "DECRYPT_AES")]
8    DecryptAes,
9    #[serde(rename = "DECRYPT_CB")]
10    DecryptCb,
11    #[serde(rename = "RATCHET_HEADER")]
12    RatchetHeader,
13    #[serde(rename = "RATCHET_SYNC")]
14    RatchetSync,
15    #[serde(untagged)]
16    Undocumented(JsonObject),
17}
18
19impl AgentCryptoError {
20    pub fn is_decrypt_aes(&self) -> bool {
21        matches!(self, Self::DecryptAes)
22    }
23    pub fn is_decrypt_cb(&self) -> bool {
24        matches!(self, Self::DecryptCb)
25    }
26    pub fn is_ratchet_header(&self) -> bool {
27        matches!(self, Self::RatchetHeader)
28    }
29    pub fn is_ratchet_sync(&self) -> bool {
30        matches!(self, Self::RatchetSync)
31    }
32}
33
34#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
35#[serde(tag = "type")]
36#[non_exhaustive]
37pub enum AgentErrorType {
38    #[serde(rename = "CMD")]
39    Cmd {
40        #[serde(rename = "cmdErr")]
41        cmd_err: CommandErrorType,
42
43        #[serde(rename = "errContext")]
44        err_context: String,
45
46        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
47        undocumented: JsonObject,
48    },
49    #[serde(rename = "CONN")]
50    Conn {
51        #[serde(rename = "connErr")]
52        conn_err: ConnectionErrorType,
53
54        #[serde(rename = "errContext")]
55        err_context: String,
56
57        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
58        undocumented: JsonObject,
59    },
60    #[serde(rename = "NO_USER")]
61    NoUser,
62    #[serde(rename = "SMP")]
63    Smp {
64        #[serde(rename = "serverAddress")]
65        server_address: String,
66
67        #[serde(rename = "smpErr")]
68        smp_err: ErrorType,
69
70        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
71        undocumented: JsonObject,
72    },
73    #[serde(rename = "NTF")]
74    Ntf {
75        #[serde(rename = "serverAddress")]
76        server_address: String,
77
78        #[serde(rename = "ntfErr")]
79        ntf_err: ErrorType,
80
81        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
82        undocumented: JsonObject,
83    },
84    #[serde(rename = "XFTP")]
85    Xftp {
86        #[serde(rename = "serverAddress")]
87        server_address: String,
88
89        #[serde(rename = "xftpErr")]
90        xftp_err: XFTPErrorType,
91
92        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
93        undocumented: JsonObject,
94    },
95    #[serde(rename = "FILE")]
96    File {
97        #[serde(rename = "fileErr")]
98        file_err: FileErrorType,
99
100        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
101        undocumented: JsonObject,
102    },
103    #[serde(rename = "PROXY")]
104    Proxy {
105        #[serde(rename = "proxyServer")]
106        proxy_server: String,
107
108        #[serde(rename = "relayServer")]
109        relay_server: String,
110
111        #[serde(rename = "proxyErr")]
112        proxy_err: ProxyClientError,
113
114        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
115        undocumented: JsonObject,
116    },
117    #[serde(rename = "RCP")]
118    Rcp {
119        #[serde(rename = "rcpErr")]
120        rcp_err: RCErrorType,
121
122        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
123        undocumented: JsonObject,
124    },
125    #[serde(rename = "BROKER")]
126    Broker {
127        #[serde(rename = "brokerAddress")]
128        broker_address: String,
129
130        #[serde(rename = "brokerErr")]
131        broker_err: BrokerErrorType,
132
133        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
134        undocumented: JsonObject,
135    },
136    #[serde(rename = "AGENT")]
137    Agent {
138        #[serde(rename = "agentErr")]
139        agent_err: SMPAgentError,
140
141        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
142        undocumented: JsonObject,
143    },
144    #[serde(rename = "NOTICE")]
145    Notice {
146        #[serde(rename = "server")]
147        server: String,
148
149        #[serde(rename = "preset", default)]
150        preset: bool,
151
152        #[serde(rename = "expiresAt", skip_serializing_if = "Option::is_none")]
153        expires_at: Option<UtcTime>,
154
155        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
156        undocumented: JsonObject,
157    },
158    #[serde(rename = "INTERNAL")]
159    Internal {
160        #[serde(rename = "internalErr")]
161        internal_err: String,
162
163        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
164        undocumented: JsonObject,
165    },
166    #[serde(rename = "CRITICAL")]
167    Critical {
168        #[serde(rename = "offerRestart", default)]
169        offer_restart: bool,
170
171        #[serde(rename = "criticalErr")]
172        critical_err: String,
173
174        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
175        undocumented: JsonObject,
176    },
177    #[serde(rename = "INACTIVE")]
178    Inactive,
179    #[serde(untagged)]
180    Undocumented(JsonObject),
181}
182
183impl AgentErrorType {
184    pub fn cmd(&self) -> Option<AgentErrorTypeCmdRef<'_>> {
185        if let Self::Cmd {
186            cmd_err,
187            err_context,
188            ..
189        } = self
190        {
191            Some(AgentErrorTypeCmdRef {
192                cmd_err,
193                err_context,
194            })
195        } else {
196            None
197        }
198    }
199    pub fn conn(&self) -> Option<AgentErrorTypeConnRef<'_>> {
200        if let Self::Conn {
201            conn_err,
202            err_context,
203            ..
204        } = self
205        {
206            Some(AgentErrorTypeConnRef {
207                conn_err,
208                err_context,
209            })
210        } else {
211            None
212        }
213    }
214    pub fn is_no_user(&self) -> bool {
215        matches!(self, Self::NoUser)
216    }
217    pub fn smp(&self) -> Option<AgentErrorTypeSmpRef<'_>> {
218        if let Self::Smp {
219            server_address,
220            smp_err,
221            ..
222        } = self
223        {
224            Some(AgentErrorTypeSmpRef {
225                server_address,
226                smp_err,
227            })
228        } else {
229            None
230        }
231    }
232    pub fn ntf(&self) -> Option<AgentErrorTypeNtfRef<'_>> {
233        if let Self::Ntf {
234            server_address,
235            ntf_err,
236            ..
237        } = self
238        {
239            Some(AgentErrorTypeNtfRef {
240                server_address,
241                ntf_err,
242            })
243        } else {
244            None
245        }
246    }
247    pub fn xftp(&self) -> Option<AgentErrorTypeXftpRef<'_>> {
248        if let Self::Xftp {
249            server_address,
250            xftp_err,
251            ..
252        } = self
253        {
254            Some(AgentErrorTypeXftpRef {
255                server_address,
256                xftp_err,
257            })
258        } else {
259            None
260        }
261    }
262    pub fn file(&self) -> Option<&FileErrorType> {
263        if let Self::File { file_err, .. } = self {
264            Some(file_err)
265        } else {
266            None
267        }
268    }
269    pub fn proxy(&self) -> Option<AgentErrorTypeProxyRef<'_>> {
270        if let Self::Proxy {
271            proxy_server,
272            relay_server,
273            proxy_err,
274            ..
275        } = self
276        {
277            Some(AgentErrorTypeProxyRef {
278                proxy_server,
279                relay_server,
280                proxy_err,
281            })
282        } else {
283            None
284        }
285    }
286    pub fn rcp(&self) -> Option<&RCErrorType> {
287        if let Self::Rcp { rcp_err, .. } = self {
288            Some(rcp_err)
289        } else {
290            None
291        }
292    }
293    pub fn broker(&self) -> Option<AgentErrorTypeBrokerRef<'_>> {
294        if let Self::Broker {
295            broker_address,
296            broker_err,
297            ..
298        } = self
299        {
300            Some(AgentErrorTypeBrokerRef {
301                broker_address,
302                broker_err,
303            })
304        } else {
305            None
306        }
307    }
308    pub fn agent(&self) -> Option<&SMPAgentError> {
309        if let Self::Agent { agent_err, .. } = self {
310            Some(agent_err)
311        } else {
312            None
313        }
314    }
315    pub fn notice(&self) -> Option<AgentErrorTypeNoticeRef<'_>> {
316        if let Self::Notice {
317            server,
318            preset,
319            expires_at,
320            ..
321        } = self
322        {
323            Some(AgentErrorTypeNoticeRef {
324                server,
325                preset,
326                expires_at,
327            })
328        } else {
329            None
330        }
331    }
332    pub fn internal(&self) -> Option<&String> {
333        if let Self::Internal { internal_err, .. } = self {
334            Some(internal_err)
335        } else {
336            None
337        }
338    }
339    pub fn critical(&self) -> Option<AgentErrorTypeCriticalRef<'_>> {
340        if let Self::Critical {
341            offer_restart,
342            critical_err,
343            ..
344        } = self
345        {
346            Some(AgentErrorTypeCriticalRef {
347                offer_restart,
348                critical_err,
349            })
350        } else {
351            None
352        }
353    }
354    pub fn is_inactive(&self) -> bool {
355        matches!(self, Self::Inactive)
356    }
357}
358#[derive(Clone, Copy)]
359pub struct AgentErrorTypeCmdRef<'a> {
360    pub cmd_err: &'a CommandErrorType,
361    pub err_context: &'a String,
362}
363#[derive(Clone, Copy)]
364pub struct AgentErrorTypeConnRef<'a> {
365    pub conn_err: &'a ConnectionErrorType,
366    pub err_context: &'a String,
367}
368#[derive(Clone, Copy)]
369pub struct AgentErrorTypeSmpRef<'a> {
370    pub server_address: &'a String,
371    pub smp_err: &'a ErrorType,
372}
373#[derive(Clone, Copy)]
374pub struct AgentErrorTypeNtfRef<'a> {
375    pub server_address: &'a String,
376    pub ntf_err: &'a ErrorType,
377}
378#[derive(Clone, Copy)]
379pub struct AgentErrorTypeXftpRef<'a> {
380    pub server_address: &'a String,
381    pub xftp_err: &'a XFTPErrorType,
382}
383#[derive(Clone, Copy)]
384pub struct AgentErrorTypeProxyRef<'a> {
385    pub proxy_server: &'a String,
386    pub relay_server: &'a String,
387    pub proxy_err: &'a ProxyClientError,
388}
389#[derive(Clone, Copy)]
390pub struct AgentErrorTypeBrokerRef<'a> {
391    pub broker_address: &'a String,
392    pub broker_err: &'a BrokerErrorType,
393}
394#[derive(Clone, Copy)]
395pub struct AgentErrorTypeNoticeRef<'a> {
396    pub server: &'a String,
397    pub preset: &'a bool,
398    pub expires_at: &'a Option<UtcTime>,
399}
400#[derive(Clone, Copy)]
401pub struct AgentErrorTypeCriticalRef<'a> {
402    pub offer_restart: &'a bool,
403    pub critical_err: &'a String,
404}
405
406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
407#[serde(tag = "type")]
408#[non_exhaustive]
409pub enum BrokerErrorType {
410    #[serde(rename = "RESPONSE")]
411    Response {
412        #[serde(rename = "respErr")]
413        resp_err: String,
414
415        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
416        undocumented: JsonObject,
417    },
418    #[serde(rename = "UNEXPECTED")]
419    Unexpected {
420        #[serde(rename = "respErr")]
421        resp_err: String,
422
423        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
424        undocumented: JsonObject,
425    },
426    #[serde(rename = "NETWORK")]
427    Network {
428        #[serde(rename = "networkError")]
429        network_error: NetworkError,
430
431        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
432        undocumented: JsonObject,
433    },
434    #[serde(rename = "HOST")]
435    Host,
436    #[serde(rename = "NO_SERVICE")]
437    NoService,
438    #[serde(rename = "TRANSPORT")]
439    Transport {
440        #[serde(rename = "transportErr")]
441        transport_err: TransportError,
442
443        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
444        undocumented: JsonObject,
445    },
446    #[serde(rename = "TIMEOUT")]
447    Timeout,
448    #[serde(untagged)]
449    Undocumented(JsonObject),
450}
451
452impl BrokerErrorType {
453    pub fn response(&self) -> Option<&String> {
454        if let Self::Response { resp_err, .. } = self {
455            Some(resp_err)
456        } else {
457            None
458        }
459    }
460    pub fn unexpected(&self) -> Option<&String> {
461        if let Self::Unexpected { resp_err, .. } = self {
462            Some(resp_err)
463        } else {
464            None
465        }
466    }
467    pub fn network(&self) -> Option<&NetworkError> {
468        if let Self::Network { network_error, .. } = self {
469            Some(network_error)
470        } else {
471            None
472        }
473    }
474    pub fn is_host(&self) -> bool {
475        matches!(self, Self::Host)
476    }
477    pub fn is_no_service(&self) -> bool {
478        matches!(self, Self::NoService)
479    }
480    pub fn transport(&self) -> Option<&TransportError> {
481        if let Self::Transport { transport_err, .. } = self {
482            Some(transport_err)
483        } else {
484            None
485        }
486    }
487    pub fn is_timeout(&self) -> bool {
488        matches!(self, Self::Timeout)
489    }
490}
491
492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
493#[serde(tag = "type")]
494#[non_exhaustive]
495pub enum ChatError {
496    #[serde(rename = "error")]
497    Error {
498        #[serde(rename = "errorType")]
499        error_type: ChatErrorType,
500
501        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
502        undocumented: JsonObject,
503    },
504    #[serde(rename = "errorAgent")]
505    ErrorAgent {
506        #[serde(rename = "agentError")]
507        agent_error: AgentErrorType,
508
509        #[serde(rename = "agentConnId")]
510        agent_conn_id: String,
511
512        #[serde(rename = "connectionEntity_", skip_serializing_if = "Option::is_none")]
513        connection_entity: Option<ConnectionEntity>,
514
515        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
516        undocumented: JsonObject,
517    },
518    #[serde(rename = "errorStore")]
519    ErrorStore {
520        #[serde(rename = "storeError")]
521        store_error: StoreError,
522
523        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
524        undocumented: JsonObject,
525    },
526    #[serde(untagged)]
527    Undocumented(JsonObject),
528}
529
530impl ChatError {
531    pub fn error(&self) -> Option<&ChatErrorType> {
532        if let Self::Error { error_type, .. } = self {
533            Some(error_type)
534        } else {
535            None
536        }
537    }
538    pub fn error_agent(&self) -> Option<ChatErrorErrorAgentRef<'_>> {
539        if let Self::ErrorAgent {
540            agent_error,
541            agent_conn_id,
542            connection_entity,
543            ..
544        } = self
545        {
546            Some(ChatErrorErrorAgentRef {
547                agent_error,
548                agent_conn_id,
549                connection_entity,
550            })
551        } else {
552            None
553        }
554    }
555    pub fn error_store(&self) -> Option<&StoreError> {
556        if let Self::ErrorStore { store_error, .. } = self {
557            Some(store_error)
558        } else {
559            None
560        }
561    }
562}
563#[derive(Clone, Copy)]
564pub struct ChatErrorErrorAgentRef<'a> {
565    pub agent_error: &'a AgentErrorType,
566    pub agent_conn_id: &'a String,
567    pub connection_entity: &'a Option<ConnectionEntity>,
568}
569
570#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
571#[serde(tag = "type")]
572#[non_exhaustive]
573pub enum ChatErrorType {
574    #[serde(rename = "noActiveUser")]
575    NoActiveUser,
576    #[serde(rename = "noConnectionUser")]
577    NoConnectionUser {
578        #[serde(rename = "agentConnId")]
579        agent_conn_id: String,
580
581        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
582        undocumented: JsonObject,
583    },
584    #[serde(rename = "noSndFileUser")]
585    NoSndFileUser {
586        #[serde(rename = "agentSndFileId")]
587        agent_snd_file_id: String,
588
589        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
590        undocumented: JsonObject,
591    },
592    #[serde(rename = "noRcvFileUser")]
593    NoRcvFileUser {
594        #[serde(rename = "agentRcvFileId")]
595        agent_rcv_file_id: String,
596
597        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
598        undocumented: JsonObject,
599    },
600    #[serde(rename = "userUnknown")]
601    UserUnknown,
602    #[serde(rename = "activeUserExists")]
603    ActiveUserExists,
604    #[serde(rename = "userExists")]
605    UserExists {
606        #[serde(rename = "contactName")]
607        contact_name: String,
608
609        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
610        undocumented: JsonObject,
611    },
612    #[serde(rename = "chatRelayExists")]
613    ChatRelayExists,
614    #[serde(rename = "differentActiveUser")]
615    DifferentActiveUser {
616        #[serde(
617            rename = "commandUserId",
618            deserialize_with = "deserialize_number_from_string"
619        )]
620        command_user_id: i64,
621
622        #[serde(
623            rename = "activeUserId",
624            deserialize_with = "deserialize_number_from_string"
625        )]
626        active_user_id: i64,
627
628        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
629        undocumented: JsonObject,
630    },
631    #[serde(rename = "cantDeleteActiveUser")]
632    CantDeleteActiveUser {
633        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
634        user_id: i64,
635
636        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
637        undocumented: JsonObject,
638    },
639    #[serde(rename = "cantDeleteLastUser")]
640    CantDeleteLastUser {
641        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
642        user_id: i64,
643
644        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
645        undocumented: JsonObject,
646    },
647    #[serde(rename = "cantHideLastUser")]
648    CantHideLastUser {
649        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
650        user_id: i64,
651
652        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
653        undocumented: JsonObject,
654    },
655    #[serde(rename = "hiddenUserAlwaysMuted")]
656    HiddenUserAlwaysMuted {
657        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
658        user_id: i64,
659
660        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
661        undocumented: JsonObject,
662    },
663    #[serde(rename = "emptyUserPassword")]
664    EmptyUserPassword {
665        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
666        user_id: i64,
667
668        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
669        undocumented: JsonObject,
670    },
671    #[serde(rename = "userAlreadyHidden")]
672    UserAlreadyHidden {
673        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
674        user_id: i64,
675
676        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
677        undocumented: JsonObject,
678    },
679    #[serde(rename = "userNotHidden")]
680    UserNotHidden {
681        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
682        user_id: i64,
683
684        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
685        undocumented: JsonObject,
686    },
687    #[serde(rename = "invalidDisplayName")]
688    InvalidDisplayName {
689        #[serde(rename = "displayName")]
690        display_name: String,
691
692        #[serde(rename = "validName")]
693        valid_name: String,
694
695        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
696        undocumented: JsonObject,
697    },
698    #[serde(rename = "chatNotStarted")]
699    ChatNotStarted,
700    #[serde(rename = "chatNotStopped")]
701    ChatNotStopped,
702    #[serde(rename = "chatStoreChanged")]
703    ChatStoreChanged,
704    #[serde(rename = "invalidConnReq")]
705    InvalidConnReq,
706    #[serde(rename = "unsupportedConnReq")]
707    UnsupportedConnReq,
708    #[serde(rename = "connReqMessageProhibited")]
709    ConnReqMessageProhibited,
710    #[serde(rename = "contactNotReady")]
711    ContactNotReady {
712        #[serde(rename = "contact")]
713        contact: Contact,
714
715        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
716        undocumented: JsonObject,
717    },
718    #[serde(rename = "contactNotActive")]
719    ContactNotActive {
720        #[serde(rename = "contact")]
721        contact: Contact,
722
723        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
724        undocumented: JsonObject,
725    },
726    #[serde(rename = "contactDisabled")]
727    ContactDisabled {
728        #[serde(rename = "contact")]
729        contact: Contact,
730
731        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
732        undocumented: JsonObject,
733    },
734    #[serde(rename = "connectionDisabled")]
735    ConnectionDisabled {
736        #[serde(rename = "connection")]
737        connection: Connection,
738
739        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
740        undocumented: JsonObject,
741    },
742    #[serde(rename = "groupUserRole")]
743    GroupUserRole {
744        #[serde(rename = "groupInfo")]
745        group_info: GroupInfo,
746
747        #[serde(rename = "requiredRole")]
748        required_role: GroupMemberRole,
749
750        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
751        undocumented: JsonObject,
752    },
753    #[serde(rename = "groupMemberInitialRole")]
754    GroupMemberInitialRole {
755        #[serde(rename = "groupInfo")]
756        group_info: GroupInfo,
757
758        #[serde(rename = "initialRole")]
759        initial_role: GroupMemberRole,
760
761        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
762        undocumented: JsonObject,
763    },
764    #[serde(rename = "contactIncognitoCantInvite")]
765    ContactIncognitoCantInvite,
766    #[serde(rename = "groupIncognitoCantInvite")]
767    GroupIncognitoCantInvite,
768    #[serde(rename = "groupContactRole")]
769    GroupContactRole {
770        #[serde(rename = "contactName")]
771        contact_name: String,
772
773        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
774        undocumented: JsonObject,
775    },
776    #[serde(rename = "groupDuplicateMember")]
777    GroupDuplicateMember {
778        #[serde(rename = "contactName")]
779        contact_name: String,
780
781        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
782        undocumented: JsonObject,
783    },
784    #[serde(rename = "groupDuplicateMemberId")]
785    GroupDuplicateMemberId,
786    #[serde(rename = "groupNotJoined")]
787    GroupNotJoined {
788        #[serde(rename = "groupInfo")]
789        group_info: GroupInfo,
790
791        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
792        undocumented: JsonObject,
793    },
794    #[serde(rename = "groupMemberNotActive")]
795    GroupMemberNotActive,
796    #[serde(rename = "cantBlockMemberForSelf")]
797    CantBlockMemberForSelf {
798        #[serde(rename = "groupInfo")]
799        group_info: GroupInfo,
800
801        #[serde(rename = "member")]
802        member: GroupMember,
803
804        #[serde(rename = "setShowMessages", default)]
805        set_show_messages: bool,
806
807        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
808        undocumented: JsonObject,
809    },
810    #[serde(rename = "groupMemberUserRemoved")]
811    GroupMemberUserRemoved,
812    #[serde(rename = "groupMemberNotFound")]
813    GroupMemberNotFound,
814    #[serde(rename = "groupCantResendInvitation")]
815    GroupCantResendInvitation {
816        #[serde(rename = "groupInfo")]
817        group_info: GroupInfo,
818
819        #[serde(rename = "contactName")]
820        contact_name: String,
821
822        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
823        undocumented: JsonObject,
824    },
825    #[serde(rename = "groupInternal")]
826    GroupInternal {
827        #[serde(rename = "message")]
828        message: String,
829
830        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
831        undocumented: JsonObject,
832    },
833    #[serde(rename = "fileNotFound")]
834    FileNotFound {
835        #[serde(rename = "message")]
836        message: String,
837
838        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
839        undocumented: JsonObject,
840    },
841    #[serde(rename = "fileSize")]
842    FileSize {
843        #[serde(rename = "filePath")]
844        file_path: String,
845
846        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
847        undocumented: JsonObject,
848    },
849    #[serde(rename = "fileAlreadyReceiving")]
850    FileAlreadyReceiving {
851        #[serde(rename = "message")]
852        message: String,
853
854        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
855        undocumented: JsonObject,
856    },
857    #[serde(rename = "fileCancelled")]
858    FileCancelled {
859        #[serde(rename = "message")]
860        message: String,
861
862        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
863        undocumented: JsonObject,
864    },
865    #[serde(rename = "fileCancel")]
866    FileCancel {
867        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
868        file_id: i64,
869
870        #[serde(rename = "message")]
871        message: String,
872
873        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
874        undocumented: JsonObject,
875    },
876    #[serde(rename = "fileAlreadyExists")]
877    FileAlreadyExists {
878        #[serde(rename = "filePath")]
879        file_path: String,
880
881        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
882        undocumented: JsonObject,
883    },
884    #[serde(rename = "fileWrite")]
885    FileWrite {
886        #[serde(rename = "filePath")]
887        file_path: String,
888
889        #[serde(rename = "message")]
890        message: String,
891
892        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
893        undocumented: JsonObject,
894    },
895    #[serde(rename = "fileSend")]
896    FileSend {
897        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
898        file_id: i64,
899
900        #[serde(rename = "agentError")]
901        agent_error: AgentErrorType,
902
903        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
904        undocumented: JsonObject,
905    },
906    #[serde(rename = "fileRcvChunk")]
907    FileRcvChunk {
908        #[serde(rename = "message")]
909        message: String,
910
911        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
912        undocumented: JsonObject,
913    },
914    #[serde(rename = "fileInternal")]
915    FileInternal {
916        #[serde(rename = "message")]
917        message: String,
918
919        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
920        undocumented: JsonObject,
921    },
922    #[serde(rename = "fileImageType")]
923    FileImageType {
924        #[serde(rename = "filePath")]
925        file_path: String,
926
927        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
928        undocumented: JsonObject,
929    },
930    #[serde(rename = "fileImageSize")]
931    FileImageSize {
932        #[serde(rename = "filePath")]
933        file_path: String,
934
935        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
936        undocumented: JsonObject,
937    },
938    #[serde(rename = "fileNotReceived")]
939    FileNotReceived {
940        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
941        file_id: i64,
942
943        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
944        undocumented: JsonObject,
945    },
946    #[serde(rename = "fileNotApproved")]
947    FileNotApproved {
948        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
949        file_id: i64,
950
951        #[serde(rename = "unknownServers")]
952        unknown_servers: Vec<String>,
953
954        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
955        undocumented: JsonObject,
956    },
957    #[serde(rename = "fallbackToSMPProhibited")]
958    FallbackToSmpProhibited {
959        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
960        file_id: i64,
961
962        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
963        undocumented: JsonObject,
964    },
965    #[serde(rename = "inlineFileProhibited")]
966    InlineFileProhibited {
967        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
968        file_id: i64,
969
970        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
971        undocumented: JsonObject,
972    },
973    #[serde(rename = "invalidForward")]
974    InvalidForward,
975    #[serde(rename = "invalidChatItemUpdate")]
976    InvalidChatItemUpdate,
977    #[serde(rename = "invalidChatItemDelete")]
978    InvalidChatItemDelete,
979    #[serde(rename = "hasCurrentCall")]
980    HasCurrentCall,
981    #[serde(rename = "noCurrentCall")]
982    NoCurrentCall,
983    #[serde(rename = "callContact")]
984    CallContact {
985        #[serde(
986            rename = "contactId",
987            deserialize_with = "deserialize_number_from_string"
988        )]
989        contact_id: i64,
990
991        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
992        undocumented: JsonObject,
993    },
994    #[serde(rename = "directMessagesProhibited")]
995    DirectMessagesProhibited {
996        #[serde(rename = "direction")]
997        direction: MsgDirection,
998
999        #[serde(rename = "contact")]
1000        contact: Contact,
1001
1002        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1003        undocumented: JsonObject,
1004    },
1005    #[serde(rename = "agentVersion")]
1006    AgentVersion,
1007    #[serde(rename = "agentNoSubResult")]
1008    AgentNoSubResult {
1009        #[serde(rename = "agentConnId")]
1010        agent_conn_id: String,
1011
1012        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1013        undocumented: JsonObject,
1014    },
1015    #[serde(rename = "commandError")]
1016    CommandError {
1017        #[serde(rename = "message")]
1018        message: String,
1019
1020        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1021        undocumented: JsonObject,
1022    },
1023    #[serde(rename = "agentCommandError")]
1024    AgentCommandError {
1025        #[serde(rename = "message")]
1026        message: String,
1027
1028        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1029        undocumented: JsonObject,
1030    },
1031    #[serde(rename = "invalidFileDescription")]
1032    InvalidFileDescription {
1033        #[serde(rename = "message")]
1034        message: String,
1035
1036        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1037        undocumented: JsonObject,
1038    },
1039    #[serde(rename = "connectionIncognitoChangeProhibited")]
1040    ConnectionIncognitoChangeProhibited,
1041    #[serde(rename = "connectionUserChangeProhibited")]
1042    ConnectionUserChangeProhibited,
1043    #[serde(rename = "peerChatVRangeIncompatible")]
1044    PeerChatVRangeIncompatible,
1045    #[serde(rename = "relayTestError")]
1046    RelayTestError {
1047        #[serde(rename = "message")]
1048        message: String,
1049
1050        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1051        undocumented: JsonObject,
1052    },
1053    #[serde(rename = "internalError")]
1054    InternalError {
1055        #[serde(rename = "message")]
1056        message: String,
1057
1058        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1059        undocumented: JsonObject,
1060    },
1061    #[serde(rename = "exception")]
1062    Exception {
1063        #[serde(rename = "message")]
1064        message: String,
1065
1066        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1067        undocumented: JsonObject,
1068    },
1069    #[serde(untagged)]
1070    Undocumented(JsonObject),
1071}
1072
1073impl ChatErrorType {
1074    pub fn is_no_active_user(&self) -> bool {
1075        matches!(self, Self::NoActiveUser)
1076    }
1077    pub fn no_connection_user(&self) -> Option<&String> {
1078        if let Self::NoConnectionUser { agent_conn_id, .. } = self {
1079            Some(agent_conn_id)
1080        } else {
1081            None
1082        }
1083    }
1084    pub fn no_snd_file_user(&self) -> Option<&String> {
1085        if let Self::NoSndFileUser {
1086            agent_snd_file_id, ..
1087        } = self
1088        {
1089            Some(agent_snd_file_id)
1090        } else {
1091            None
1092        }
1093    }
1094    pub fn no_rcv_file_user(&self) -> Option<&String> {
1095        if let Self::NoRcvFileUser {
1096            agent_rcv_file_id, ..
1097        } = self
1098        {
1099            Some(agent_rcv_file_id)
1100        } else {
1101            None
1102        }
1103    }
1104    pub fn is_user_unknown(&self) -> bool {
1105        matches!(self, Self::UserUnknown)
1106    }
1107    pub fn is_active_user_exists(&self) -> bool {
1108        matches!(self, Self::ActiveUserExists)
1109    }
1110    pub fn user_exists(&self) -> Option<&String> {
1111        if let Self::UserExists { contact_name, .. } = self {
1112            Some(contact_name)
1113        } else {
1114            None
1115        }
1116    }
1117    pub fn is_chat_relay_exists(&self) -> bool {
1118        matches!(self, Self::ChatRelayExists)
1119    }
1120    pub fn different_active_user(&self) -> Option<ChatErrorTypeDifferentActiveUserRef<'_>> {
1121        if let Self::DifferentActiveUser {
1122            command_user_id,
1123            active_user_id,
1124            ..
1125        } = self
1126        {
1127            Some(ChatErrorTypeDifferentActiveUserRef {
1128                command_user_id,
1129                active_user_id,
1130            })
1131        } else {
1132            None
1133        }
1134    }
1135    pub fn cant_delete_active_user(&self) -> Option<&i64> {
1136        if let Self::CantDeleteActiveUser { user_id, .. } = self {
1137            Some(user_id)
1138        } else {
1139            None
1140        }
1141    }
1142    pub fn cant_delete_last_user(&self) -> Option<&i64> {
1143        if let Self::CantDeleteLastUser { user_id, .. } = self {
1144            Some(user_id)
1145        } else {
1146            None
1147        }
1148    }
1149    pub fn cant_hide_last_user(&self) -> Option<&i64> {
1150        if let Self::CantHideLastUser { user_id, .. } = self {
1151            Some(user_id)
1152        } else {
1153            None
1154        }
1155    }
1156    pub fn hidden_user_always_muted(&self) -> Option<&i64> {
1157        if let Self::HiddenUserAlwaysMuted { user_id, .. } = self {
1158            Some(user_id)
1159        } else {
1160            None
1161        }
1162    }
1163    pub fn empty_user_password(&self) -> Option<&i64> {
1164        if let Self::EmptyUserPassword { user_id, .. } = self {
1165            Some(user_id)
1166        } else {
1167            None
1168        }
1169    }
1170    pub fn user_already_hidden(&self) -> Option<&i64> {
1171        if let Self::UserAlreadyHidden { user_id, .. } = self {
1172            Some(user_id)
1173        } else {
1174            None
1175        }
1176    }
1177    pub fn user_not_hidden(&self) -> Option<&i64> {
1178        if let Self::UserNotHidden { user_id, .. } = self {
1179            Some(user_id)
1180        } else {
1181            None
1182        }
1183    }
1184    pub fn invalid_display_name(&self) -> Option<ChatErrorTypeInvalidDisplayNameRef<'_>> {
1185        if let Self::InvalidDisplayName {
1186            display_name,
1187            valid_name,
1188            ..
1189        } = self
1190        {
1191            Some(ChatErrorTypeInvalidDisplayNameRef {
1192                display_name,
1193                valid_name,
1194            })
1195        } else {
1196            None
1197        }
1198    }
1199    pub fn is_chat_not_started(&self) -> bool {
1200        matches!(self, Self::ChatNotStarted)
1201    }
1202    pub fn is_chat_not_stopped(&self) -> bool {
1203        matches!(self, Self::ChatNotStopped)
1204    }
1205    pub fn is_chat_store_changed(&self) -> bool {
1206        matches!(self, Self::ChatStoreChanged)
1207    }
1208    pub fn is_invalid_conn_req(&self) -> bool {
1209        matches!(self, Self::InvalidConnReq)
1210    }
1211    pub fn is_unsupported_conn_req(&self) -> bool {
1212        matches!(self, Self::UnsupportedConnReq)
1213    }
1214    pub fn is_conn_req_message_prohibited(&self) -> bool {
1215        matches!(self, Self::ConnReqMessageProhibited)
1216    }
1217    pub fn contact_not_ready(&self) -> Option<&Contact> {
1218        if let Self::ContactNotReady { contact, .. } = self {
1219            Some(contact)
1220        } else {
1221            None
1222        }
1223    }
1224    pub fn contact_not_active(&self) -> Option<&Contact> {
1225        if let Self::ContactNotActive { contact, .. } = self {
1226            Some(contact)
1227        } else {
1228            None
1229        }
1230    }
1231    pub fn contact_disabled(&self) -> Option<&Contact> {
1232        if let Self::ContactDisabled { contact, .. } = self {
1233            Some(contact)
1234        } else {
1235            None
1236        }
1237    }
1238    pub fn connection_disabled(&self) -> Option<&Connection> {
1239        if let Self::ConnectionDisabled { connection, .. } = self {
1240            Some(connection)
1241        } else {
1242            None
1243        }
1244    }
1245    pub fn group_user_role(&self) -> Option<ChatErrorTypeGroupUserRoleRef<'_>> {
1246        if let Self::GroupUserRole {
1247            group_info,
1248            required_role,
1249            ..
1250        } = self
1251        {
1252            Some(ChatErrorTypeGroupUserRoleRef {
1253                group_info,
1254                required_role,
1255            })
1256        } else {
1257            None
1258        }
1259    }
1260    pub fn group_member_initial_role(&self) -> Option<ChatErrorTypeGroupMemberInitialRoleRef<'_>> {
1261        if let Self::GroupMemberInitialRole {
1262            group_info,
1263            initial_role,
1264            ..
1265        } = self
1266        {
1267            Some(ChatErrorTypeGroupMemberInitialRoleRef {
1268                group_info,
1269                initial_role,
1270            })
1271        } else {
1272            None
1273        }
1274    }
1275    pub fn is_contact_incognito_cant_invite(&self) -> bool {
1276        matches!(self, Self::ContactIncognitoCantInvite)
1277    }
1278    pub fn is_group_incognito_cant_invite(&self) -> bool {
1279        matches!(self, Self::GroupIncognitoCantInvite)
1280    }
1281    pub fn group_contact_role(&self) -> Option<&String> {
1282        if let Self::GroupContactRole { contact_name, .. } = self {
1283            Some(contact_name)
1284        } else {
1285            None
1286        }
1287    }
1288    pub fn group_duplicate_member(&self) -> Option<&String> {
1289        if let Self::GroupDuplicateMember { contact_name, .. } = self {
1290            Some(contact_name)
1291        } else {
1292            None
1293        }
1294    }
1295    pub fn is_group_duplicate_member_id(&self) -> bool {
1296        matches!(self, Self::GroupDuplicateMemberId)
1297    }
1298    pub fn group_not_joined(&self) -> Option<&GroupInfo> {
1299        if let Self::GroupNotJoined { group_info, .. } = self {
1300            Some(group_info)
1301        } else {
1302            None
1303        }
1304    }
1305    pub fn is_group_member_not_active(&self) -> bool {
1306        matches!(self, Self::GroupMemberNotActive)
1307    }
1308    pub fn cant_block_member_for_self(&self) -> Option<ChatErrorTypeCantBlockMemberForSelfRef<'_>> {
1309        if let Self::CantBlockMemberForSelf {
1310            group_info,
1311            member,
1312            set_show_messages,
1313            ..
1314        } = self
1315        {
1316            Some(ChatErrorTypeCantBlockMemberForSelfRef {
1317                group_info,
1318                member,
1319                set_show_messages,
1320            })
1321        } else {
1322            None
1323        }
1324    }
1325    pub fn is_group_member_user_removed(&self) -> bool {
1326        matches!(self, Self::GroupMemberUserRemoved)
1327    }
1328    pub fn is_group_member_not_found(&self) -> bool {
1329        matches!(self, Self::GroupMemberNotFound)
1330    }
1331    pub fn group_cant_resend_invitation(
1332        &self,
1333    ) -> Option<ChatErrorTypeGroupCantResendInvitationRef<'_>> {
1334        if let Self::GroupCantResendInvitation {
1335            group_info,
1336            contact_name,
1337            ..
1338        } = self
1339        {
1340            Some(ChatErrorTypeGroupCantResendInvitationRef {
1341                group_info,
1342                contact_name,
1343            })
1344        } else {
1345            None
1346        }
1347    }
1348    pub fn group_internal(&self) -> Option<&String> {
1349        if let Self::GroupInternal { message, .. } = self {
1350            Some(message)
1351        } else {
1352            None
1353        }
1354    }
1355    pub fn file_not_found(&self) -> Option<&String> {
1356        if let Self::FileNotFound { message, .. } = self {
1357            Some(message)
1358        } else {
1359            None
1360        }
1361    }
1362    pub fn file_size(&self) -> Option<&String> {
1363        if let Self::FileSize { file_path, .. } = self {
1364            Some(file_path)
1365        } else {
1366            None
1367        }
1368    }
1369    pub fn file_already_receiving(&self) -> Option<&String> {
1370        if let Self::FileAlreadyReceiving { message, .. } = self {
1371            Some(message)
1372        } else {
1373            None
1374        }
1375    }
1376    pub fn file_cancelled(&self) -> Option<&String> {
1377        if let Self::FileCancelled { message, .. } = self {
1378            Some(message)
1379        } else {
1380            None
1381        }
1382    }
1383    pub fn file_cancel(&self) -> Option<ChatErrorTypeFileCancelRef<'_>> {
1384        if let Self::FileCancel {
1385            file_id, message, ..
1386        } = self
1387        {
1388            Some(ChatErrorTypeFileCancelRef { file_id, message })
1389        } else {
1390            None
1391        }
1392    }
1393    pub fn file_already_exists(&self) -> Option<&String> {
1394        if let Self::FileAlreadyExists { file_path, .. } = self {
1395            Some(file_path)
1396        } else {
1397            None
1398        }
1399    }
1400    pub fn file_write(&self) -> Option<ChatErrorTypeFileWriteRef<'_>> {
1401        if let Self::FileWrite {
1402            file_path, message, ..
1403        } = self
1404        {
1405            Some(ChatErrorTypeFileWriteRef { file_path, message })
1406        } else {
1407            None
1408        }
1409    }
1410    pub fn file_send(&self) -> Option<ChatErrorTypeFileSendRef<'_>> {
1411        if let Self::FileSend {
1412            file_id,
1413            agent_error,
1414            ..
1415        } = self
1416        {
1417            Some(ChatErrorTypeFileSendRef {
1418                file_id,
1419                agent_error,
1420            })
1421        } else {
1422            None
1423        }
1424    }
1425    pub fn file_rcv_chunk(&self) -> Option<&String> {
1426        if let Self::FileRcvChunk { message, .. } = self {
1427            Some(message)
1428        } else {
1429            None
1430        }
1431    }
1432    pub fn file_internal(&self) -> Option<&String> {
1433        if let Self::FileInternal { message, .. } = self {
1434            Some(message)
1435        } else {
1436            None
1437        }
1438    }
1439    pub fn file_image_type(&self) -> Option<&String> {
1440        if let Self::FileImageType { file_path, .. } = self {
1441            Some(file_path)
1442        } else {
1443            None
1444        }
1445    }
1446    pub fn file_image_size(&self) -> Option<&String> {
1447        if let Self::FileImageSize { file_path, .. } = self {
1448            Some(file_path)
1449        } else {
1450            None
1451        }
1452    }
1453    pub fn file_not_received(&self) -> Option<&i64> {
1454        if let Self::FileNotReceived { file_id, .. } = self {
1455            Some(file_id)
1456        } else {
1457            None
1458        }
1459    }
1460    pub fn file_not_approved(&self) -> Option<ChatErrorTypeFileNotApprovedRef<'_>> {
1461        if let Self::FileNotApproved {
1462            file_id,
1463            unknown_servers,
1464            ..
1465        } = self
1466        {
1467            Some(ChatErrorTypeFileNotApprovedRef {
1468                file_id,
1469                unknown_servers,
1470            })
1471        } else {
1472            None
1473        }
1474    }
1475    pub fn fallback_to_smp_prohibited(&self) -> Option<&i64> {
1476        if let Self::FallbackToSmpProhibited { file_id, .. } = self {
1477            Some(file_id)
1478        } else {
1479            None
1480        }
1481    }
1482    pub fn inline_file_prohibited(&self) -> Option<&i64> {
1483        if let Self::InlineFileProhibited { file_id, .. } = self {
1484            Some(file_id)
1485        } else {
1486            None
1487        }
1488    }
1489    pub fn is_invalid_forward(&self) -> bool {
1490        matches!(self, Self::InvalidForward)
1491    }
1492    pub fn is_invalid_chat_item_update(&self) -> bool {
1493        matches!(self, Self::InvalidChatItemUpdate)
1494    }
1495    pub fn is_invalid_chat_item_delete(&self) -> bool {
1496        matches!(self, Self::InvalidChatItemDelete)
1497    }
1498    pub fn is_has_current_call(&self) -> bool {
1499        matches!(self, Self::HasCurrentCall)
1500    }
1501    pub fn is_no_current_call(&self) -> bool {
1502        matches!(self, Self::NoCurrentCall)
1503    }
1504    pub fn call_contact(&self) -> Option<&i64> {
1505        if let Self::CallContact { contact_id, .. } = self {
1506            Some(contact_id)
1507        } else {
1508            None
1509        }
1510    }
1511    pub fn direct_messages_prohibited(
1512        &self,
1513    ) -> Option<ChatErrorTypeDirectMessagesProhibitedRef<'_>> {
1514        if let Self::DirectMessagesProhibited {
1515            direction, contact, ..
1516        } = self
1517        {
1518            Some(ChatErrorTypeDirectMessagesProhibitedRef { direction, contact })
1519        } else {
1520            None
1521        }
1522    }
1523    pub fn is_agent_version(&self) -> bool {
1524        matches!(self, Self::AgentVersion)
1525    }
1526    pub fn agent_no_sub_result(&self) -> Option<&String> {
1527        if let Self::AgentNoSubResult { agent_conn_id, .. } = self {
1528            Some(agent_conn_id)
1529        } else {
1530            None
1531        }
1532    }
1533    pub fn command_error(&self) -> Option<&String> {
1534        if let Self::CommandError { message, .. } = self {
1535            Some(message)
1536        } else {
1537            None
1538        }
1539    }
1540    pub fn agent_command_error(&self) -> Option<&String> {
1541        if let Self::AgentCommandError { message, .. } = self {
1542            Some(message)
1543        } else {
1544            None
1545        }
1546    }
1547    pub fn invalid_file_description(&self) -> Option<&String> {
1548        if let Self::InvalidFileDescription { message, .. } = self {
1549            Some(message)
1550        } else {
1551            None
1552        }
1553    }
1554    pub fn is_connection_incognito_change_prohibited(&self) -> bool {
1555        matches!(self, Self::ConnectionIncognitoChangeProhibited)
1556    }
1557    pub fn is_connection_user_change_prohibited(&self) -> bool {
1558        matches!(self, Self::ConnectionUserChangeProhibited)
1559    }
1560    pub fn is_peer_chat_v_range_incompatible(&self) -> bool {
1561        matches!(self, Self::PeerChatVRangeIncompatible)
1562    }
1563    pub fn relay_test_error(&self) -> Option<&String> {
1564        if let Self::RelayTestError { message, .. } = self {
1565            Some(message)
1566        } else {
1567            None
1568        }
1569    }
1570    pub fn internal_error(&self) -> Option<&String> {
1571        if let Self::InternalError { message, .. } = self {
1572            Some(message)
1573        } else {
1574            None
1575        }
1576    }
1577    pub fn exception(&self) -> Option<&String> {
1578        if let Self::Exception { message, .. } = self {
1579            Some(message)
1580        } else {
1581            None
1582        }
1583    }
1584}
1585#[derive(Clone, Copy)]
1586pub struct ChatErrorTypeDifferentActiveUserRef<'a> {
1587    pub command_user_id: &'a i64,
1588    pub active_user_id: &'a i64,
1589}
1590#[derive(Clone, Copy)]
1591pub struct ChatErrorTypeInvalidDisplayNameRef<'a> {
1592    pub display_name: &'a String,
1593    pub valid_name: &'a String,
1594}
1595#[derive(Clone, Copy)]
1596pub struct ChatErrorTypeGroupUserRoleRef<'a> {
1597    pub group_info: &'a GroupInfo,
1598    pub required_role: &'a GroupMemberRole,
1599}
1600#[derive(Clone, Copy)]
1601pub struct ChatErrorTypeGroupMemberInitialRoleRef<'a> {
1602    pub group_info: &'a GroupInfo,
1603    pub initial_role: &'a GroupMemberRole,
1604}
1605#[derive(Clone, Copy)]
1606pub struct ChatErrorTypeCantBlockMemberForSelfRef<'a> {
1607    pub group_info: &'a GroupInfo,
1608    pub member: &'a GroupMember,
1609    pub set_show_messages: &'a bool,
1610}
1611#[derive(Clone, Copy)]
1612pub struct ChatErrorTypeGroupCantResendInvitationRef<'a> {
1613    pub group_info: &'a GroupInfo,
1614    pub contact_name: &'a String,
1615}
1616#[derive(Clone, Copy)]
1617pub struct ChatErrorTypeFileCancelRef<'a> {
1618    pub file_id: &'a i64,
1619    pub message: &'a String,
1620}
1621#[derive(Clone, Copy)]
1622pub struct ChatErrorTypeFileWriteRef<'a> {
1623    pub file_path: &'a String,
1624    pub message: &'a String,
1625}
1626#[derive(Clone, Copy)]
1627pub struct ChatErrorTypeFileSendRef<'a> {
1628    pub file_id: &'a i64,
1629    pub agent_error: &'a AgentErrorType,
1630}
1631#[derive(Clone, Copy)]
1632pub struct ChatErrorTypeFileNotApprovedRef<'a> {
1633    pub file_id: &'a i64,
1634    pub unknown_servers: &'a Vec<String>,
1635}
1636#[derive(Clone, Copy)]
1637pub struct ChatErrorTypeDirectMessagesProhibitedRef<'a> {
1638    pub direction: &'a MsgDirection,
1639    pub contact: &'a Contact,
1640}
1641
1642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1643#[serde(tag = "type")]
1644#[non_exhaustive]
1645pub enum CommandError {
1646    #[serde(rename = "UNKNOWN")]
1647    Unknown,
1648    #[serde(rename = "SYNTAX")]
1649    Syntax,
1650    #[serde(rename = "PROHIBITED")]
1651    Prohibited,
1652    #[serde(rename = "NO_AUTH")]
1653    NoAuth,
1654    #[serde(rename = "HAS_AUTH")]
1655    HasAuth,
1656    #[serde(rename = "NO_ENTITY")]
1657    NoEntity,
1658    #[serde(untagged)]
1659    Undocumented(JsonObject),
1660}
1661
1662impl CommandError {
1663    pub fn is_unknown(&self) -> bool {
1664        matches!(self, Self::Unknown)
1665    }
1666    pub fn is_syntax(&self) -> bool {
1667        matches!(self, Self::Syntax)
1668    }
1669    pub fn is_prohibited(&self) -> bool {
1670        matches!(self, Self::Prohibited)
1671    }
1672    pub fn is_no_auth(&self) -> bool {
1673        matches!(self, Self::NoAuth)
1674    }
1675    pub fn is_has_auth(&self) -> bool {
1676        matches!(self, Self::HasAuth)
1677    }
1678    pub fn is_no_entity(&self) -> bool {
1679        matches!(self, Self::NoEntity)
1680    }
1681}
1682
1683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1684#[serde(tag = "type")]
1685#[non_exhaustive]
1686pub enum CommandErrorType {
1687    #[serde(rename = "PROHIBITED")]
1688    Prohibited,
1689    #[serde(rename = "SYNTAX")]
1690    Syntax,
1691    #[serde(rename = "NO_CONN")]
1692    NoConn,
1693    #[serde(rename = "SIZE")]
1694    Size,
1695    #[serde(rename = "LARGE")]
1696    Large,
1697    #[serde(untagged)]
1698    Undocumented(JsonObject),
1699}
1700
1701impl CommandErrorType {
1702    pub fn is_prohibited(&self) -> bool {
1703        matches!(self, Self::Prohibited)
1704    }
1705    pub fn is_syntax(&self) -> bool {
1706        matches!(self, Self::Syntax)
1707    }
1708    pub fn is_no_conn(&self) -> bool {
1709        matches!(self, Self::NoConn)
1710    }
1711    pub fn is_size(&self) -> bool {
1712        matches!(self, Self::Size)
1713    }
1714    pub fn is_large(&self) -> bool {
1715        matches!(self, Self::Large)
1716    }
1717}
1718
1719#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1720#[serde(tag = "type")]
1721#[non_exhaustive]
1722pub enum ConnectionErrorType {
1723    #[serde(rename = "NOT_FOUND")]
1724    NotFound,
1725    #[serde(rename = "DUPLICATE")]
1726    Duplicate,
1727    #[serde(rename = "SIMPLEX")]
1728    Simplex,
1729    #[serde(rename = "NOT_ACCEPTED")]
1730    NotAccepted,
1731    #[serde(rename = "NOT_AVAILABLE")]
1732    NotAvailable,
1733    #[serde(untagged)]
1734    Undocumented(JsonObject),
1735}
1736
1737impl ConnectionErrorType {
1738    pub fn is_not_found(&self) -> bool {
1739        matches!(self, Self::NotFound)
1740    }
1741    pub fn is_duplicate(&self) -> bool {
1742        matches!(self, Self::Duplicate)
1743    }
1744    pub fn is_simplex(&self) -> bool {
1745        matches!(self, Self::Simplex)
1746    }
1747    pub fn is_not_accepted(&self) -> bool {
1748        matches!(self, Self::NotAccepted)
1749    }
1750    pub fn is_not_available(&self) -> bool {
1751        matches!(self, Self::NotAvailable)
1752    }
1753}
1754
1755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1756#[serde(tag = "type")]
1757#[non_exhaustive]
1758pub enum ErrorType {
1759    #[serde(rename = "BLOCK")]
1760    Block,
1761    #[serde(rename = "SESSION")]
1762    Session,
1763    #[serde(rename = "CMD")]
1764    Cmd {
1765        #[serde(rename = "cmdErr")]
1766        cmd_err: CommandError,
1767
1768        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1769        undocumented: JsonObject,
1770    },
1771    #[serde(rename = "PROXY")]
1772    Proxy {
1773        #[serde(rename = "proxyErr")]
1774        proxy_err: Arc<ProxyError>,
1775
1776        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1777        undocumented: JsonObject,
1778    },
1779    #[serde(rename = "AUTH")]
1780    Auth,
1781    #[serde(rename = "BLOCKED")]
1782    Blocked {
1783        #[serde(rename = "blockInfo")]
1784        block_info: BlockingInfo,
1785
1786        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1787        undocumented: JsonObject,
1788    },
1789    #[serde(rename = "SERVICE")]
1790    Service,
1791    #[serde(rename = "CRYPTO")]
1792    Crypto,
1793    #[serde(rename = "QUOTA")]
1794    Quota,
1795    #[serde(rename = "STORE")]
1796    Store {
1797        #[serde(rename = "storeErr")]
1798        store_err: String,
1799
1800        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1801        undocumented: JsonObject,
1802    },
1803    #[serde(rename = "NO_MSG")]
1804    NoMsg,
1805    #[serde(rename = "LARGE_MSG")]
1806    LargeMsg,
1807    #[serde(rename = "EXPIRED")]
1808    Expired,
1809    #[serde(rename = "INTERNAL")]
1810    Internal,
1811    #[serde(rename = "DUPLICATE_")]
1812    Duplicate,
1813    #[serde(untagged)]
1814    Undocumented(JsonObject),
1815}
1816
1817impl ErrorType {
1818    pub fn is_block(&self) -> bool {
1819        matches!(self, Self::Block)
1820    }
1821    pub fn is_session(&self) -> bool {
1822        matches!(self, Self::Session)
1823    }
1824    pub fn cmd(&self) -> Option<&CommandError> {
1825        if let Self::Cmd { cmd_err, .. } = self {
1826            Some(cmd_err)
1827        } else {
1828            None
1829        }
1830    }
1831    pub fn proxy(&self) -> Option<&Arc<ProxyError>> {
1832        if let Self::Proxy { proxy_err, .. } = self {
1833            Some(proxy_err)
1834        } else {
1835            None
1836        }
1837    }
1838    pub fn is_auth(&self) -> bool {
1839        matches!(self, Self::Auth)
1840    }
1841    pub fn blocked(&self) -> Option<&BlockingInfo> {
1842        if let Self::Blocked { block_info, .. } = self {
1843            Some(block_info)
1844        } else {
1845            None
1846        }
1847    }
1848    pub fn is_service(&self) -> bool {
1849        matches!(self, Self::Service)
1850    }
1851    pub fn is_crypto(&self) -> bool {
1852        matches!(self, Self::Crypto)
1853    }
1854    pub fn is_quota(&self) -> bool {
1855        matches!(self, Self::Quota)
1856    }
1857    pub fn store(&self) -> Option<&String> {
1858        if let Self::Store { store_err, .. } = self {
1859            Some(store_err)
1860        } else {
1861            None
1862        }
1863    }
1864    pub fn is_no_msg(&self) -> bool {
1865        matches!(self, Self::NoMsg)
1866    }
1867    pub fn is_large_msg(&self) -> bool {
1868        matches!(self, Self::LargeMsg)
1869    }
1870    pub fn is_expired(&self) -> bool {
1871        matches!(self, Self::Expired)
1872    }
1873    pub fn is_internal(&self) -> bool {
1874        matches!(self, Self::Internal)
1875    }
1876    pub fn is_duplicate(&self) -> bool {
1877        matches!(self, Self::Duplicate)
1878    }
1879}
1880
1881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1882#[serde(tag = "type")]
1883#[non_exhaustive]
1884pub enum FileError {
1885    #[serde(rename = "auth")]
1886    Auth,
1887    #[serde(rename = "blocked")]
1888    Blocked {
1889        #[serde(rename = "server")]
1890        server: String,
1891
1892        #[serde(rename = "blockInfo")]
1893        block_info: BlockingInfo,
1894
1895        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1896        undocumented: JsonObject,
1897    },
1898    #[serde(rename = "noFile")]
1899    NoFile,
1900    #[serde(rename = "relay")]
1901    Relay {
1902        #[serde(rename = "srvError")]
1903        srv_error: SrvError,
1904
1905        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1906        undocumented: JsonObject,
1907    },
1908    #[serde(rename = "other")]
1909    Other {
1910        #[serde(rename = "fileError")]
1911        file_error: String,
1912
1913        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1914        undocumented: JsonObject,
1915    },
1916    #[serde(untagged)]
1917    Undocumented(JsonObject),
1918}
1919
1920impl FileError {
1921    pub fn is_auth(&self) -> bool {
1922        matches!(self, Self::Auth)
1923    }
1924    pub fn blocked(&self) -> Option<FileErrorBlockedRef<'_>> {
1925        if let Self::Blocked {
1926            server, block_info, ..
1927        } = self
1928        {
1929            Some(FileErrorBlockedRef { server, block_info })
1930        } else {
1931            None
1932        }
1933    }
1934    pub fn is_no_file(&self) -> bool {
1935        matches!(self, Self::NoFile)
1936    }
1937    pub fn relay(&self) -> Option<&SrvError> {
1938        if let Self::Relay { srv_error, .. } = self {
1939            Some(srv_error)
1940        } else {
1941            None
1942        }
1943    }
1944    pub fn other(&self) -> Option<&String> {
1945        if let Self::Other { file_error, .. } = self {
1946            Some(file_error)
1947        } else {
1948            None
1949        }
1950    }
1951}
1952#[derive(Clone, Copy)]
1953pub struct FileErrorBlockedRef<'a> {
1954    pub server: &'a String,
1955    pub block_info: &'a BlockingInfo,
1956}
1957
1958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1959#[serde(tag = "type")]
1960#[non_exhaustive]
1961pub enum FileErrorType {
1962    #[serde(rename = "NOT_APPROVED")]
1963    NotApproved,
1964    #[serde(rename = "SIZE")]
1965    Size,
1966    #[serde(rename = "REDIRECT")]
1967    Redirect {
1968        #[serde(rename = "redirectError")]
1969        redirect_error: String,
1970
1971        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1972        undocumented: JsonObject,
1973    },
1974    #[serde(rename = "FILE_IO")]
1975    FileIo {
1976        #[serde(rename = "fileIOError")]
1977        file_io_error: String,
1978
1979        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
1980        undocumented: JsonObject,
1981    },
1982    #[serde(rename = "NO_FILE")]
1983    NoFile,
1984    #[serde(untagged)]
1985    Undocumented(JsonObject),
1986}
1987
1988impl FileErrorType {
1989    pub fn is_not_approved(&self) -> bool {
1990        matches!(self, Self::NotApproved)
1991    }
1992    pub fn is_size(&self) -> bool {
1993        matches!(self, Self::Size)
1994    }
1995    pub fn redirect(&self) -> Option<&String> {
1996        if let Self::Redirect { redirect_error, .. } = self {
1997            Some(redirect_error)
1998        } else {
1999            None
2000        }
2001    }
2002    pub fn file_io(&self) -> Option<&String> {
2003        if let Self::FileIo { file_io_error, .. } = self {
2004            Some(file_io_error)
2005        } else {
2006            None
2007        }
2008    }
2009    pub fn is_no_file(&self) -> bool {
2010        matches!(self, Self::NoFile)
2011    }
2012}
2013
2014#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2015#[non_exhaustive]
2016pub enum HandshakeError {
2017    #[default]
2018    #[serde(rename = "PARSE")]
2019    Parse,
2020    #[serde(rename = "IDENTITY")]
2021    Identity,
2022    #[serde(rename = "BAD_AUTH")]
2023    BadAuth,
2024    #[serde(rename = "BAD_SERVICE")]
2025    BadService,
2026}
2027
2028#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
2029#[non_exhaustive]
2030pub enum MsgDecryptError {
2031    #[default]
2032    #[serde(rename = "ratchetHeader")]
2033    RatchetHeader,
2034    #[serde(rename = "tooManySkipped")]
2035    TooManySkipped,
2036    #[serde(rename = "ratchetEarlier")]
2037    RatchetEarlier,
2038    #[serde(rename = "other")]
2039    Other,
2040    #[serde(rename = "ratchetSync")]
2041    RatchetSync,
2042}
2043
2044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2045#[serde(tag = "type")]
2046#[non_exhaustive]
2047pub enum MsgErrorType {
2048    #[serde(rename = "msgSkipped")]
2049    MsgSkipped {
2050        #[serde(
2051            rename = "fromMsgId",
2052            deserialize_with = "deserialize_number_from_string"
2053        )]
2054        from_msg_id: i64,
2055
2056        #[serde(
2057            rename = "toMsgId",
2058            deserialize_with = "deserialize_number_from_string"
2059        )]
2060        to_msg_id: i64,
2061
2062        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2063        undocumented: JsonObject,
2064    },
2065    #[serde(rename = "msgBadId")]
2066    MsgBadId {
2067        #[serde(rename = "msgId", deserialize_with = "deserialize_number_from_string")]
2068        msg_id: i64,
2069
2070        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2071        undocumented: JsonObject,
2072    },
2073    #[serde(rename = "msgBadHash")]
2074    MsgBadHash,
2075    #[serde(rename = "msgDuplicate")]
2076    MsgDuplicate,
2077    #[serde(untagged)]
2078    Undocumented(JsonObject),
2079}
2080
2081impl MsgErrorType {
2082    pub fn msg_skipped(&self) -> Option<MsgErrorTypeMsgSkippedRef<'_>> {
2083        if let Self::MsgSkipped {
2084            from_msg_id,
2085            to_msg_id,
2086            ..
2087        } = self
2088        {
2089            Some(MsgErrorTypeMsgSkippedRef {
2090                from_msg_id,
2091                to_msg_id,
2092            })
2093        } else {
2094            None
2095        }
2096    }
2097    pub fn msg_bad_id(&self) -> Option<&i64> {
2098        if let Self::MsgBadId { msg_id, .. } = self {
2099            Some(msg_id)
2100        } else {
2101            None
2102        }
2103    }
2104    pub fn is_msg_bad_hash(&self) -> bool {
2105        matches!(self, Self::MsgBadHash)
2106    }
2107    pub fn is_msg_duplicate(&self) -> bool {
2108        matches!(self, Self::MsgDuplicate)
2109    }
2110}
2111#[derive(Clone, Copy)]
2112pub struct MsgErrorTypeMsgSkippedRef<'a> {
2113    pub from_msg_id: &'a i64,
2114    pub to_msg_id: &'a i64,
2115}
2116
2117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2118#[serde(tag = "type")]
2119#[non_exhaustive]
2120pub enum NetworkError {
2121    #[serde(rename = "connectError")]
2122    ConnectError {
2123        #[serde(rename = "connectError")]
2124        connect_error: String,
2125
2126        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2127        undocumented: JsonObject,
2128    },
2129    #[serde(rename = "tLSError")]
2130    TLsError {
2131        #[serde(rename = "tlsError")]
2132        tls_error: String,
2133
2134        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2135        undocumented: JsonObject,
2136    },
2137    #[serde(rename = "unknownCAError")]
2138    UnknownCaError,
2139    #[serde(rename = "failedError")]
2140    FailedError,
2141    #[serde(rename = "timeoutError")]
2142    TimeoutError,
2143    #[serde(rename = "subscribeError")]
2144    SubscribeError {
2145        #[serde(rename = "subscribeError")]
2146        subscribe_error: String,
2147
2148        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2149        undocumented: JsonObject,
2150    },
2151    #[serde(untagged)]
2152    Undocumented(JsonObject),
2153}
2154
2155impl NetworkError {
2156    pub fn connect_error(&self) -> Option<&String> {
2157        if let Self::ConnectError { connect_error, .. } = self {
2158            Some(connect_error)
2159        } else {
2160            None
2161        }
2162    }
2163    pub fn t_ls_error(&self) -> Option<&String> {
2164        if let Self::TLsError { tls_error, .. } = self {
2165            Some(tls_error)
2166        } else {
2167            None
2168        }
2169    }
2170    pub fn is_unknown_ca_error(&self) -> bool {
2171        matches!(self, Self::UnknownCaError)
2172    }
2173    pub fn is_failed_error(&self) -> bool {
2174        matches!(self, Self::FailedError)
2175    }
2176    pub fn is_timeout_error(&self) -> bool {
2177        matches!(self, Self::TimeoutError)
2178    }
2179    pub fn subscribe_error(&self) -> Option<&String> {
2180        if let Self::SubscribeError {
2181            subscribe_error, ..
2182        } = self
2183        {
2184            Some(subscribe_error)
2185        } else {
2186            None
2187        }
2188    }
2189}
2190
2191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2192#[serde(tag = "type")]
2193#[non_exhaustive]
2194pub enum ProxyClientError {
2195    #[serde(rename = "protocolError")]
2196    ProtocolError {
2197        #[serde(rename = "protocolErr")]
2198        protocol_err: ErrorType,
2199
2200        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2201        undocumented: JsonObject,
2202    },
2203    #[serde(rename = "unexpectedResponse")]
2204    UnexpectedResponse {
2205        #[serde(rename = "responseStr")]
2206        response_str: String,
2207
2208        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2209        undocumented: JsonObject,
2210    },
2211    #[serde(rename = "responseError")]
2212    ResponseError {
2213        #[serde(rename = "responseErr")]
2214        response_err: ErrorType,
2215
2216        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2217        undocumented: JsonObject,
2218    },
2219    #[serde(untagged)]
2220    Undocumented(JsonObject),
2221}
2222
2223impl ProxyClientError {
2224    pub fn protocol_error(&self) -> Option<&ErrorType> {
2225        if let Self::ProtocolError { protocol_err, .. } = self {
2226            Some(protocol_err)
2227        } else {
2228            None
2229        }
2230    }
2231    pub fn unexpected_response(&self) -> Option<&String> {
2232        if let Self::UnexpectedResponse { response_str, .. } = self {
2233            Some(response_str)
2234        } else {
2235            None
2236        }
2237    }
2238    pub fn response_error(&self) -> Option<&ErrorType> {
2239        if let Self::ResponseError { response_err, .. } = self {
2240            Some(response_err)
2241        } else {
2242            None
2243        }
2244    }
2245}
2246
2247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2248#[serde(tag = "type")]
2249#[non_exhaustive]
2250pub enum ProxyError {
2251    #[serde(rename = "PROTOCOL")]
2252    Protocol {
2253        #[serde(rename = "protocolErr")]
2254        protocol_err: ErrorType,
2255
2256        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2257        undocumented: JsonObject,
2258    },
2259    #[serde(rename = "BROKER")]
2260    Broker {
2261        #[serde(rename = "brokerErr")]
2262        broker_err: BrokerErrorType,
2263
2264        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2265        undocumented: JsonObject,
2266    },
2267    #[serde(rename = "BASIC_AUTH")]
2268    BasicAuth,
2269    #[serde(rename = "NO_SESSION")]
2270    NoSession,
2271    #[serde(untagged)]
2272    Undocumented(JsonObject),
2273}
2274
2275impl ProxyError {
2276    pub fn protocol(&self) -> Option<&ErrorType> {
2277        if let Self::Protocol { protocol_err, .. } = self {
2278            Some(protocol_err)
2279        } else {
2280            None
2281        }
2282    }
2283    pub fn broker(&self) -> Option<&BrokerErrorType> {
2284        if let Self::Broker { broker_err, .. } = self {
2285            Some(broker_err)
2286        } else {
2287            None
2288        }
2289    }
2290    pub fn is_basic_auth(&self) -> bool {
2291        matches!(self, Self::BasicAuth)
2292    }
2293    pub fn is_no_session(&self) -> bool {
2294        matches!(self, Self::NoSession)
2295    }
2296}
2297
2298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2299#[serde(tag = "type")]
2300#[non_exhaustive]
2301pub enum RCErrorType {
2302    #[serde(rename = "internal")]
2303    Internal {
2304        #[serde(rename = "internalErr")]
2305        internal_err: String,
2306
2307        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2308        undocumented: JsonObject,
2309    },
2310    #[serde(rename = "identity")]
2311    Identity,
2312    #[serde(rename = "noLocalAddress")]
2313    NoLocalAddress,
2314    #[serde(rename = "newController")]
2315    NewController,
2316    #[serde(rename = "notDiscovered")]
2317    NotDiscovered,
2318    #[serde(rename = "tLSStartFailed")]
2319    TLsStartFailed,
2320    #[serde(rename = "exception")]
2321    Exception {
2322        #[serde(rename = "exception")]
2323        exception: String,
2324
2325        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2326        undocumented: JsonObject,
2327    },
2328    #[serde(rename = "ctrlAuth")]
2329    CtrlAuth,
2330    #[serde(rename = "ctrlNotFound")]
2331    CtrlNotFound,
2332    #[serde(rename = "ctrlError")]
2333    CtrlError {
2334        #[serde(rename = "ctrlErr")]
2335        ctrl_err: String,
2336
2337        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2338        undocumented: JsonObject,
2339    },
2340    #[serde(rename = "invitation")]
2341    Invitation,
2342    #[serde(rename = "version")]
2343    Version,
2344    #[serde(rename = "encrypt")]
2345    Encrypt,
2346    #[serde(rename = "decrypt")]
2347    Decrypt,
2348    #[serde(rename = "blockSize")]
2349    BlockSize,
2350    #[serde(rename = "syntax")]
2351    Syntax {
2352        #[serde(rename = "syntaxErr")]
2353        syntax_err: String,
2354
2355        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2356        undocumented: JsonObject,
2357    },
2358    #[serde(untagged)]
2359    Undocumented(JsonObject),
2360}
2361
2362impl RCErrorType {
2363    pub fn internal(&self) -> Option<&String> {
2364        if let Self::Internal { internal_err, .. } = self {
2365            Some(internal_err)
2366        } else {
2367            None
2368        }
2369    }
2370    pub fn is_identity(&self) -> bool {
2371        matches!(self, Self::Identity)
2372    }
2373    pub fn is_no_local_address(&self) -> bool {
2374        matches!(self, Self::NoLocalAddress)
2375    }
2376    pub fn is_new_controller(&self) -> bool {
2377        matches!(self, Self::NewController)
2378    }
2379    pub fn is_not_discovered(&self) -> bool {
2380        matches!(self, Self::NotDiscovered)
2381    }
2382    pub fn is_t_ls_start_failed(&self) -> bool {
2383        matches!(self, Self::TLsStartFailed)
2384    }
2385    pub fn exception(&self) -> Option<&String> {
2386        if let Self::Exception { exception, .. } = self {
2387            Some(exception)
2388        } else {
2389            None
2390        }
2391    }
2392    pub fn is_ctrl_auth(&self) -> bool {
2393        matches!(self, Self::CtrlAuth)
2394    }
2395    pub fn is_ctrl_not_found(&self) -> bool {
2396        matches!(self, Self::CtrlNotFound)
2397    }
2398    pub fn ctrl_error(&self) -> Option<&String> {
2399        if let Self::CtrlError { ctrl_err, .. } = self {
2400            Some(ctrl_err)
2401        } else {
2402            None
2403        }
2404    }
2405    pub fn is_invitation(&self) -> bool {
2406        matches!(self, Self::Invitation)
2407    }
2408    pub fn is_version(&self) -> bool {
2409        matches!(self, Self::Version)
2410    }
2411    pub fn is_encrypt(&self) -> bool {
2412        matches!(self, Self::Encrypt)
2413    }
2414    pub fn is_decrypt(&self) -> bool {
2415        matches!(self, Self::Decrypt)
2416    }
2417    pub fn is_block_size(&self) -> bool {
2418        matches!(self, Self::BlockSize)
2419    }
2420    pub fn syntax(&self) -> Option<&String> {
2421        if let Self::Syntax { syntax_err, .. } = self {
2422            Some(syntax_err)
2423        } else {
2424            None
2425        }
2426    }
2427}
2428
2429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2430#[serde(tag = "type")]
2431#[non_exhaustive]
2432pub enum RcvMsgError {
2433    #[serde(rename = "dropped")]
2434    Dropped {
2435        #[serde(
2436            rename = "attempts",
2437            deserialize_with = "deserialize_number_from_string"
2438        )]
2439        attempts: i32,
2440
2441        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2442        undocumented: JsonObject,
2443    },
2444    #[serde(rename = "parseError")]
2445    ParseError {
2446        #[serde(rename = "parseError")]
2447        parse_error: String,
2448
2449        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2450        undocumented: JsonObject,
2451    },
2452    #[serde(untagged)]
2453    Undocumented(JsonObject),
2454}
2455
2456impl RcvMsgError {
2457    pub fn dropped(&self) -> Option<&i32> {
2458        if let Self::Dropped { attempts, .. } = self {
2459            Some(attempts)
2460        } else {
2461            None
2462        }
2463    }
2464    pub fn parse_error(&self) -> Option<&String> {
2465        if let Self::ParseError { parse_error, .. } = self {
2466            Some(parse_error)
2467        } else {
2468            None
2469        }
2470    }
2471}
2472
2473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2474#[serde(tag = "type")]
2475#[non_exhaustive]
2476pub enum SMPAgentError {
2477    #[serde(rename = "A_MESSAGE")]
2478    AMessage,
2479    #[serde(rename = "A_PROHIBITED")]
2480    AProhibited {
2481        #[serde(rename = "prohibitedErr")]
2482        prohibited_err: String,
2483
2484        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2485        undocumented: JsonObject,
2486    },
2487    #[serde(rename = "A_VERSION")]
2488    AVersion,
2489    #[serde(rename = "A_LINK")]
2490    ALink {
2491        #[serde(rename = "linkErr")]
2492        link_err: String,
2493
2494        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2495        undocumented: JsonObject,
2496    },
2497    #[serde(rename = "A_CRYPTO")]
2498    ACrypto {
2499        #[serde(rename = "cryptoErr")]
2500        crypto_err: AgentCryptoError,
2501
2502        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2503        undocumented: JsonObject,
2504    },
2505    #[serde(rename = "A_DUPLICATE")]
2506    ADuplicate {
2507        #[serde(rename = "droppedMsg_", skip_serializing_if = "Option::is_none")]
2508        dropped_msg: Option<DroppedMsg>,
2509
2510        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2511        undocumented: JsonObject,
2512    },
2513    #[serde(rename = "A_QUEUE")]
2514    AQueue {
2515        #[serde(rename = "queueErr")]
2516        queue_err: String,
2517
2518        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2519        undocumented: JsonObject,
2520    },
2521    #[serde(untagged)]
2522    Undocumented(JsonObject),
2523}
2524
2525impl SMPAgentError {
2526    pub fn is_a_message(&self) -> bool {
2527        matches!(self, Self::AMessage)
2528    }
2529    pub fn a_prohibited(&self) -> Option<&String> {
2530        if let Self::AProhibited { prohibited_err, .. } = self {
2531            Some(prohibited_err)
2532        } else {
2533            None
2534        }
2535    }
2536    pub fn is_a_version(&self) -> bool {
2537        matches!(self, Self::AVersion)
2538    }
2539    pub fn a_link(&self) -> Option<&String> {
2540        if let Self::ALink { link_err, .. } = self {
2541            Some(link_err)
2542        } else {
2543            None
2544        }
2545    }
2546    pub fn a_crypto(&self) -> Option<&AgentCryptoError> {
2547        if let Self::ACrypto { crypto_err, .. } = self {
2548            Some(crypto_err)
2549        } else {
2550            None
2551        }
2552    }
2553    pub fn a_duplicate(&self) -> Option<&Option<DroppedMsg>> {
2554        if let Self::ADuplicate { dropped_msg, .. } = self {
2555            Some(dropped_msg)
2556        } else {
2557            None
2558        }
2559    }
2560    pub fn a_queue(&self) -> Option<&String> {
2561        if let Self::AQueue { queue_err, .. } = self {
2562            Some(queue_err)
2563        } else {
2564            None
2565        }
2566    }
2567}
2568
2569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2570#[serde(tag = "type")]
2571#[non_exhaustive]
2572pub enum SndError {
2573    #[serde(rename = "auth")]
2574    Auth,
2575    #[serde(rename = "quota")]
2576    Quota,
2577    #[serde(rename = "expired")]
2578    Expired,
2579    #[serde(rename = "relay")]
2580    Relay {
2581        #[serde(rename = "srvError")]
2582        srv_error: SrvError,
2583
2584        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2585        undocumented: JsonObject,
2586    },
2587    #[serde(rename = "proxy")]
2588    Proxy {
2589        #[serde(rename = "proxyServer")]
2590        proxy_server: String,
2591
2592        #[serde(rename = "srvError")]
2593        srv_error: SrvError,
2594
2595        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2596        undocumented: JsonObject,
2597    },
2598    #[serde(rename = "proxyRelay")]
2599    ProxyRelay {
2600        #[serde(rename = "proxyServer")]
2601        proxy_server: String,
2602
2603        #[serde(rename = "srvError")]
2604        srv_error: SrvError,
2605
2606        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2607        undocumented: JsonObject,
2608    },
2609    #[serde(rename = "other")]
2610    Other {
2611        #[serde(rename = "sndError")]
2612        snd_error: String,
2613
2614        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2615        undocumented: JsonObject,
2616    },
2617    #[serde(untagged)]
2618    Undocumented(JsonObject),
2619}
2620
2621impl SndError {
2622    pub fn is_auth(&self) -> bool {
2623        matches!(self, Self::Auth)
2624    }
2625    pub fn is_quota(&self) -> bool {
2626        matches!(self, Self::Quota)
2627    }
2628    pub fn is_expired(&self) -> bool {
2629        matches!(self, Self::Expired)
2630    }
2631    pub fn relay(&self) -> Option<&SrvError> {
2632        if let Self::Relay { srv_error, .. } = self {
2633            Some(srv_error)
2634        } else {
2635            None
2636        }
2637    }
2638    pub fn proxy(&self) -> Option<SndErrorProxyRef<'_>> {
2639        if let Self::Proxy {
2640            proxy_server,
2641            srv_error,
2642            ..
2643        } = self
2644        {
2645            Some(SndErrorProxyRef {
2646                proxy_server,
2647                srv_error,
2648            })
2649        } else {
2650            None
2651        }
2652    }
2653    pub fn proxy_relay(&self) -> Option<SndErrorProxyRelayRef<'_>> {
2654        if let Self::ProxyRelay {
2655            proxy_server,
2656            srv_error,
2657            ..
2658        } = self
2659        {
2660            Some(SndErrorProxyRelayRef {
2661                proxy_server,
2662                srv_error,
2663            })
2664        } else {
2665            None
2666        }
2667    }
2668    pub fn other(&self) -> Option<&String> {
2669        if let Self::Other { snd_error, .. } = self {
2670            Some(snd_error)
2671        } else {
2672            None
2673        }
2674    }
2675}
2676#[derive(Clone, Copy)]
2677pub struct SndErrorProxyRef<'a> {
2678    pub proxy_server: &'a String,
2679    pub srv_error: &'a SrvError,
2680}
2681#[derive(Clone, Copy)]
2682pub struct SndErrorProxyRelayRef<'a> {
2683    pub proxy_server: &'a String,
2684    pub srv_error: &'a SrvError,
2685}
2686
2687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2688#[serde(tag = "type")]
2689#[non_exhaustive]
2690pub enum SrvError {
2691    #[serde(rename = "host")]
2692    Host,
2693    #[serde(rename = "version")]
2694    Version,
2695    #[serde(rename = "other")]
2696    Other {
2697        #[serde(rename = "srvError")]
2698        srv_error: String,
2699
2700        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2701        undocumented: JsonObject,
2702    },
2703    #[serde(untagged)]
2704    Undocumented(JsonObject),
2705}
2706
2707impl SrvError {
2708    pub fn is_host(&self) -> bool {
2709        matches!(self, Self::Host)
2710    }
2711    pub fn is_version(&self) -> bool {
2712        matches!(self, Self::Version)
2713    }
2714    pub fn other(&self) -> Option<&String> {
2715        if let Self::Other { srv_error, .. } = self {
2716            Some(srv_error)
2717        } else {
2718            None
2719        }
2720    }
2721}
2722
2723#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2724#[serde(tag = "type")]
2725#[non_exhaustive]
2726pub enum StoreError {
2727    #[serde(rename = "duplicateName")]
2728    DuplicateName,
2729    #[serde(rename = "userNotFound")]
2730    UserNotFound {
2731        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
2732        user_id: i64,
2733
2734        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2735        undocumented: JsonObject,
2736    },
2737    #[serde(rename = "relayUserNotFound")]
2738    RelayUserNotFound,
2739    #[serde(rename = "userNotFoundByName")]
2740    UserNotFoundByName {
2741        #[serde(rename = "contactName")]
2742        contact_name: String,
2743
2744        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2745        undocumented: JsonObject,
2746    },
2747    #[serde(rename = "userNotFoundByContactId")]
2748    UserNotFoundByContactId {
2749        #[serde(
2750            rename = "contactId",
2751            deserialize_with = "deserialize_number_from_string"
2752        )]
2753        contact_id: i64,
2754
2755        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2756        undocumented: JsonObject,
2757    },
2758    #[serde(rename = "userNotFoundByGroupId")]
2759    UserNotFoundByGroupId {
2760        #[serde(
2761            rename = "groupId",
2762            deserialize_with = "deserialize_number_from_string"
2763        )]
2764        group_id: i64,
2765
2766        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2767        undocumented: JsonObject,
2768    },
2769    #[serde(rename = "userNotFoundByFileId")]
2770    UserNotFoundByFileId {
2771        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
2772        file_id: i64,
2773
2774        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2775        undocumented: JsonObject,
2776    },
2777    #[serde(rename = "userNotFoundByContactRequestId")]
2778    UserNotFoundByContactRequestId {
2779        #[serde(
2780            rename = "contactRequestId",
2781            deserialize_with = "deserialize_number_from_string"
2782        )]
2783        contact_request_id: i64,
2784
2785        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2786        undocumented: JsonObject,
2787    },
2788    #[serde(rename = "contactNotFound")]
2789    ContactNotFound {
2790        #[serde(
2791            rename = "contactId",
2792            deserialize_with = "deserialize_number_from_string"
2793        )]
2794        contact_id: i64,
2795
2796        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2797        undocumented: JsonObject,
2798    },
2799    #[serde(rename = "contactNotFoundByName")]
2800    ContactNotFoundByName {
2801        #[serde(rename = "contactName")]
2802        contact_name: String,
2803
2804        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2805        undocumented: JsonObject,
2806    },
2807    #[serde(rename = "contactNotFoundByMemberId")]
2808    ContactNotFoundByMemberId {
2809        #[serde(
2810            rename = "groupMemberId",
2811            deserialize_with = "deserialize_number_from_string"
2812        )]
2813        group_member_id: i64,
2814
2815        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2816        undocumented: JsonObject,
2817    },
2818    #[serde(rename = "contactNotReady")]
2819    ContactNotReady {
2820        #[serde(rename = "contactName")]
2821        contact_name: String,
2822
2823        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2824        undocumented: JsonObject,
2825    },
2826    #[serde(rename = "duplicateContactLink")]
2827    DuplicateContactLink,
2828    #[serde(rename = "userContactLinkNotFound")]
2829    UserContactLinkNotFound,
2830    #[serde(rename = "contactRequestNotFound")]
2831    ContactRequestNotFound {
2832        #[serde(
2833            rename = "contactRequestId",
2834            deserialize_with = "deserialize_number_from_string"
2835        )]
2836        contact_request_id: i64,
2837
2838        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2839        undocumented: JsonObject,
2840    },
2841    #[serde(rename = "contactRequestNotFoundByName")]
2842    ContactRequestNotFoundByName {
2843        #[serde(rename = "contactName")]
2844        contact_name: String,
2845
2846        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2847        undocumented: JsonObject,
2848    },
2849    #[serde(rename = "invalidContactRequestEntity")]
2850    InvalidContactRequestEntity {
2851        #[serde(
2852            rename = "contactRequestId",
2853            deserialize_with = "deserialize_number_from_string"
2854        )]
2855        contact_request_id: i64,
2856
2857        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2858        undocumented: JsonObject,
2859    },
2860    #[serde(rename = "invalidBusinessChatContactRequest")]
2861    InvalidBusinessChatContactRequest,
2862    #[serde(rename = "groupNotFound")]
2863    GroupNotFound {
2864        #[serde(
2865            rename = "groupId",
2866            deserialize_with = "deserialize_number_from_string"
2867        )]
2868        group_id: i64,
2869
2870        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2871        undocumented: JsonObject,
2872    },
2873    #[serde(rename = "groupNotFoundByName")]
2874    GroupNotFoundByName {
2875        #[serde(rename = "groupName")]
2876        group_name: String,
2877
2878        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2879        undocumented: JsonObject,
2880    },
2881    #[serde(rename = "groupMemberNameNotFound")]
2882    GroupMemberNameNotFound {
2883        #[serde(
2884            rename = "groupId",
2885            deserialize_with = "deserialize_number_from_string"
2886        )]
2887        group_id: i64,
2888
2889        #[serde(rename = "groupMemberName")]
2890        group_member_name: String,
2891
2892        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2893        undocumented: JsonObject,
2894    },
2895    #[serde(rename = "groupMemberNotFound")]
2896    GroupMemberNotFound {
2897        #[serde(
2898            rename = "groupMemberId",
2899            deserialize_with = "deserialize_number_from_string"
2900        )]
2901        group_member_id: i64,
2902
2903        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2904        undocumented: JsonObject,
2905    },
2906    #[serde(rename = "groupMemberNotFoundByIndex")]
2907    GroupMemberNotFoundByIndex {
2908        #[serde(
2909            rename = "groupMemberIndex",
2910            deserialize_with = "deserialize_number_from_string"
2911        )]
2912        group_member_index: i64,
2913
2914        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2915        undocumented: JsonObject,
2916    },
2917    #[serde(rename = "memberRelationsVectorNotFound")]
2918    MemberRelationsVectorNotFound {
2919        #[serde(
2920            rename = "groupMemberId",
2921            deserialize_with = "deserialize_number_from_string"
2922        )]
2923        group_member_id: i64,
2924
2925        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2926        undocumented: JsonObject,
2927    },
2928    #[serde(rename = "groupHostMemberNotFound")]
2929    GroupHostMemberNotFound {
2930        #[serde(
2931            rename = "groupId",
2932            deserialize_with = "deserialize_number_from_string"
2933        )]
2934        group_id: i64,
2935
2936        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2937        undocumented: JsonObject,
2938    },
2939    #[serde(rename = "groupMemberNotFoundByMemberId")]
2940    GroupMemberNotFoundByMemberId {
2941        #[serde(rename = "memberId")]
2942        member_id: String,
2943
2944        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2945        undocumented: JsonObject,
2946    },
2947    #[serde(rename = "memberContactGroupMemberNotFound")]
2948    MemberContactGroupMemberNotFound {
2949        #[serde(
2950            rename = "contactId",
2951            deserialize_with = "deserialize_number_from_string"
2952        )]
2953        contact_id: i64,
2954
2955        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2956        undocumented: JsonObject,
2957    },
2958    #[serde(rename = "invalidMemberRelationUpdate")]
2959    InvalidMemberRelationUpdate,
2960    #[serde(rename = "groupWithoutUser")]
2961    GroupWithoutUser,
2962    #[serde(rename = "duplicateGroupMember")]
2963    DuplicateGroupMember,
2964    #[serde(rename = "duplicateMemberId")]
2965    DuplicateMemberId,
2966    #[serde(rename = "groupAlreadyJoined")]
2967    GroupAlreadyJoined,
2968    #[serde(rename = "groupInvitationNotFound")]
2969    GroupInvitationNotFound,
2970    #[serde(rename = "noteFolderAlreadyExists")]
2971    NoteFolderAlreadyExists {
2972        #[serde(
2973            rename = "noteFolderId",
2974            deserialize_with = "deserialize_number_from_string"
2975        )]
2976        note_folder_id: i64,
2977
2978        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2979        undocumented: JsonObject,
2980    },
2981    #[serde(rename = "noteFolderNotFound")]
2982    NoteFolderNotFound {
2983        #[serde(
2984            rename = "noteFolderId",
2985            deserialize_with = "deserialize_number_from_string"
2986        )]
2987        note_folder_id: i64,
2988
2989        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
2990        undocumented: JsonObject,
2991    },
2992    #[serde(rename = "userNoteFolderNotFound")]
2993    UserNoteFolderNotFound,
2994    #[serde(rename = "sndFileNotFound")]
2995    SndFileNotFound {
2996        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
2997        file_id: i64,
2998
2999        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3000        undocumented: JsonObject,
3001    },
3002    #[serde(rename = "sndFileInvalid")]
3003    SndFileInvalid {
3004        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3005        file_id: i64,
3006
3007        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3008        undocumented: JsonObject,
3009    },
3010    #[serde(rename = "rcvFileNotFound")]
3011    RcvFileNotFound {
3012        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3013        file_id: i64,
3014
3015        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3016        undocumented: JsonObject,
3017    },
3018    #[serde(rename = "rcvFileDescrNotFound")]
3019    RcvFileDescrNotFound {
3020        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3021        file_id: i64,
3022
3023        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3024        undocumented: JsonObject,
3025    },
3026    #[serde(rename = "fileNotFound")]
3027    FileNotFound {
3028        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3029        file_id: i64,
3030
3031        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3032        undocumented: JsonObject,
3033    },
3034    #[serde(rename = "rcvFileInvalid")]
3035    RcvFileInvalid {
3036        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3037        file_id: i64,
3038
3039        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3040        undocumented: JsonObject,
3041    },
3042    #[serde(rename = "rcvFileInvalidDescrPart")]
3043    RcvFileInvalidDescrPart,
3044    #[serde(rename = "localFileNoTransfer")]
3045    LocalFileNoTransfer {
3046        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3047        file_id: i64,
3048
3049        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3050        undocumented: JsonObject,
3051    },
3052    #[serde(rename = "sharedMsgIdNotFoundByFileId")]
3053    SharedMsgIdNotFoundByFileId {
3054        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3055        file_id: i64,
3056
3057        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3058        undocumented: JsonObject,
3059    },
3060    #[serde(rename = "fileIdNotFoundBySharedMsgId")]
3061    FileIdNotFoundBySharedMsgId {
3062        #[serde(rename = "sharedMsgId")]
3063        shared_msg_id: String,
3064
3065        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3066        undocumented: JsonObject,
3067    },
3068    #[serde(rename = "sndFileNotFoundXFTP")]
3069    SndFileNotFoundXftp {
3070        #[serde(rename = "agentSndFileId")]
3071        agent_snd_file_id: String,
3072
3073        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3074        undocumented: JsonObject,
3075    },
3076    #[serde(rename = "rcvFileNotFoundXFTP")]
3077    RcvFileNotFoundXftp {
3078        #[serde(rename = "agentRcvFileId")]
3079        agent_rcv_file_id: String,
3080
3081        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3082        undocumented: JsonObject,
3083    },
3084    #[serde(rename = "connectionNotFound")]
3085    ConnectionNotFound {
3086        #[serde(rename = "agentConnId")]
3087        agent_conn_id: String,
3088
3089        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3090        undocumented: JsonObject,
3091    },
3092    #[serde(rename = "connectionNotFoundById")]
3093    ConnectionNotFoundById {
3094        #[serde(rename = "connId", deserialize_with = "deserialize_number_from_string")]
3095        conn_id: i64,
3096
3097        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3098        undocumented: JsonObject,
3099    },
3100    #[serde(rename = "connectionNotFoundByMemberId")]
3101    ConnectionNotFoundByMemberId {
3102        #[serde(
3103            rename = "groupMemberId",
3104            deserialize_with = "deserialize_number_from_string"
3105        )]
3106        group_member_id: i64,
3107
3108        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3109        undocumented: JsonObject,
3110    },
3111    #[serde(rename = "pendingConnectionNotFound")]
3112    PendingConnectionNotFound {
3113        #[serde(rename = "connId", deserialize_with = "deserialize_number_from_string")]
3114        conn_id: i64,
3115
3116        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3117        undocumented: JsonObject,
3118    },
3119    #[serde(rename = "uniqueID")]
3120    UniqueId,
3121    #[serde(rename = "largeMsg")]
3122    LargeMsg,
3123    #[serde(rename = "internalError")]
3124    InternalError {
3125        #[serde(rename = "message")]
3126        message: String,
3127
3128        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3129        undocumented: JsonObject,
3130    },
3131    #[serde(rename = "dBException")]
3132    DBException {
3133        #[serde(rename = "message")]
3134        message: String,
3135
3136        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3137        undocumented: JsonObject,
3138    },
3139    #[serde(rename = "dBBusyError")]
3140    DBBusyError {
3141        #[serde(rename = "message")]
3142        message: String,
3143
3144        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3145        undocumented: JsonObject,
3146    },
3147    #[serde(rename = "badChatItem")]
3148    BadChatItem {
3149        #[serde(rename = "itemId", deserialize_with = "deserialize_number_from_string")]
3150        item_id: i64,
3151
3152        #[serde(rename = "itemTs", skip_serializing_if = "Option::is_none")]
3153        item_ts: Option<UtcTime>,
3154
3155        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3156        undocumented: JsonObject,
3157    },
3158    #[serde(rename = "chatItemNotFound")]
3159    ChatItemNotFound {
3160        #[serde(rename = "itemId", deserialize_with = "deserialize_number_from_string")]
3161        item_id: i64,
3162
3163        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3164        undocumented: JsonObject,
3165    },
3166    #[serde(rename = "chatItemNotFoundByText")]
3167    ChatItemNotFoundByText {
3168        #[serde(rename = "text")]
3169        text: String,
3170
3171        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3172        undocumented: JsonObject,
3173    },
3174    #[serde(rename = "chatItemSharedMsgIdNotFound")]
3175    ChatItemSharedMsgIdNotFound {
3176        #[serde(rename = "sharedMsgId")]
3177        shared_msg_id: String,
3178
3179        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3180        undocumented: JsonObject,
3181    },
3182    #[serde(rename = "chatItemNotFoundByFileId")]
3183    ChatItemNotFoundByFileId {
3184        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3185        file_id: i64,
3186
3187        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3188        undocumented: JsonObject,
3189    },
3190    #[serde(rename = "chatItemNotFoundByContactId")]
3191    ChatItemNotFoundByContactId {
3192        #[serde(
3193            rename = "contactId",
3194            deserialize_with = "deserialize_number_from_string"
3195        )]
3196        contact_id: i64,
3197
3198        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3199        undocumented: JsonObject,
3200    },
3201    #[serde(rename = "chatItemNotFoundByGroupId")]
3202    ChatItemNotFoundByGroupId {
3203        #[serde(
3204            rename = "groupId",
3205            deserialize_with = "deserialize_number_from_string"
3206        )]
3207        group_id: i64,
3208
3209        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3210        undocumented: JsonObject,
3211    },
3212    #[serde(rename = "profileNotFound")]
3213    ProfileNotFound {
3214        #[serde(
3215            rename = "profileId",
3216            deserialize_with = "deserialize_number_from_string"
3217        )]
3218        profile_id: i64,
3219
3220        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3221        undocumented: JsonObject,
3222    },
3223    #[serde(rename = "duplicateGroupLink")]
3224    DuplicateGroupLink {
3225        #[serde(rename = "groupInfo")]
3226        group_info: GroupInfo,
3227
3228        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3229        undocumented: JsonObject,
3230    },
3231    #[serde(rename = "groupLinkNotFound")]
3232    GroupLinkNotFound {
3233        #[serde(rename = "groupInfo")]
3234        group_info: GroupInfo,
3235
3236        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3237        undocumented: JsonObject,
3238    },
3239    #[serde(rename = "hostMemberIdNotFound")]
3240    HostMemberIdNotFound {
3241        #[serde(
3242            rename = "groupId",
3243            deserialize_with = "deserialize_number_from_string"
3244        )]
3245        group_id: i64,
3246
3247        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3248        undocumented: JsonObject,
3249    },
3250    #[serde(rename = "contactNotFoundByFileId")]
3251    ContactNotFoundByFileId {
3252        #[serde(rename = "fileId", deserialize_with = "deserialize_number_from_string")]
3253        file_id: i64,
3254
3255        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3256        undocumented: JsonObject,
3257    },
3258    #[serde(rename = "noGroupSndStatus")]
3259    NoGroupSndStatus {
3260        #[serde(rename = "itemId", deserialize_with = "deserialize_number_from_string")]
3261        item_id: i64,
3262
3263        #[serde(
3264            rename = "groupMemberId",
3265            deserialize_with = "deserialize_number_from_string"
3266        )]
3267        group_member_id: i64,
3268
3269        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3270        undocumented: JsonObject,
3271    },
3272    #[serde(rename = "duplicateGroupMessage")]
3273    DuplicateGroupMessage {
3274        #[serde(
3275            rename = "groupId",
3276            deserialize_with = "deserialize_number_from_string"
3277        )]
3278        group_id: i64,
3279
3280        #[serde(rename = "sharedMsgId")]
3281        shared_msg_id: String,
3282
3283        #[serde(
3284            rename = "authorGroupMemberId",
3285            skip_serializing_if = "Option::is_none",
3286            deserialize_with = "deserialize_option_number_from_string",
3287            default
3288        )]
3289        author_group_member_id: Option<i64>,
3290
3291        #[serde(
3292            rename = "forwardedByGroupMemberId",
3293            skip_serializing_if = "Option::is_none",
3294            deserialize_with = "deserialize_option_number_from_string",
3295            default
3296        )]
3297        forwarded_by_group_member_id: Option<i64>,
3298
3299        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3300        undocumented: JsonObject,
3301    },
3302    #[serde(rename = "remoteHostNotFound")]
3303    RemoteHostNotFound {
3304        #[serde(
3305            rename = "remoteHostId",
3306            deserialize_with = "deserialize_number_from_string"
3307        )]
3308        remote_host_id: i64,
3309
3310        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3311        undocumented: JsonObject,
3312    },
3313    #[serde(rename = "remoteHostUnknown")]
3314    RemoteHostUnknown,
3315    #[serde(rename = "remoteHostDuplicateCA")]
3316    RemoteHostDuplicateCa,
3317    #[serde(rename = "remoteCtrlNotFound")]
3318    RemoteCtrlNotFound {
3319        #[serde(
3320            rename = "remoteCtrlId",
3321            deserialize_with = "deserialize_number_from_string"
3322        )]
3323        remote_ctrl_id: i64,
3324
3325        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3326        undocumented: JsonObject,
3327    },
3328    #[serde(rename = "remoteCtrlDuplicateCA")]
3329    RemoteCtrlDuplicateCa,
3330    #[serde(rename = "prohibitedDeleteUser")]
3331    ProhibitedDeleteUser {
3332        #[serde(rename = "userId", deserialize_with = "deserialize_number_from_string")]
3333        user_id: i64,
3334
3335        #[serde(
3336            rename = "contactId",
3337            deserialize_with = "deserialize_number_from_string"
3338        )]
3339        contact_id: i64,
3340
3341        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3342        undocumented: JsonObject,
3343    },
3344    #[serde(rename = "operatorNotFound")]
3345    OperatorNotFound {
3346        #[serde(
3347            rename = "serverOperatorId",
3348            deserialize_with = "deserialize_number_from_string"
3349        )]
3350        server_operator_id: i64,
3351
3352        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3353        undocumented: JsonObject,
3354    },
3355    #[serde(rename = "usageConditionsNotFound")]
3356    UsageConditionsNotFound,
3357    #[serde(rename = "userChatRelayNotFound")]
3358    UserChatRelayNotFound {
3359        #[serde(
3360            rename = "chatRelayId",
3361            deserialize_with = "deserialize_number_from_string"
3362        )]
3363        chat_relay_id: i64,
3364
3365        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3366        undocumented: JsonObject,
3367    },
3368    #[serde(rename = "groupRelayNotFound")]
3369    GroupRelayNotFound {
3370        #[serde(
3371            rename = "groupRelayId",
3372            deserialize_with = "deserialize_number_from_string"
3373        )]
3374        group_relay_id: i64,
3375
3376        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3377        undocumented: JsonObject,
3378    },
3379    #[serde(rename = "groupRelayNotFoundByMemberId")]
3380    GroupRelayNotFoundByMemberId {
3381        #[serde(
3382            rename = "groupMemberId",
3383            deserialize_with = "deserialize_number_from_string"
3384        )]
3385        group_member_id: i64,
3386
3387        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3388        undocumented: JsonObject,
3389    },
3390    #[serde(rename = "invalidQuote")]
3391    InvalidQuote,
3392    #[serde(rename = "invalidMention")]
3393    InvalidMention,
3394    #[serde(rename = "invalidDeliveryTask")]
3395    InvalidDeliveryTask {
3396        #[serde(rename = "taskId", deserialize_with = "deserialize_number_from_string")]
3397        task_id: i64,
3398
3399        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3400        undocumented: JsonObject,
3401    },
3402    #[serde(rename = "deliveryTaskNotFound")]
3403    DeliveryTaskNotFound {
3404        #[serde(rename = "taskId", deserialize_with = "deserialize_number_from_string")]
3405        task_id: i64,
3406
3407        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3408        undocumented: JsonObject,
3409    },
3410    #[serde(rename = "invalidDeliveryJob")]
3411    InvalidDeliveryJob {
3412        #[serde(rename = "jobId", deserialize_with = "deserialize_number_from_string")]
3413        job_id: i64,
3414
3415        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3416        undocumented: JsonObject,
3417    },
3418    #[serde(rename = "deliveryJobNotFound")]
3419    DeliveryJobNotFound {
3420        #[serde(rename = "jobId", deserialize_with = "deserialize_number_from_string")]
3421        job_id: i64,
3422
3423        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3424        undocumented: JsonObject,
3425    },
3426    #[serde(rename = "workItemError")]
3427    WorkItemError {
3428        #[serde(rename = "errContext")]
3429        err_context: String,
3430
3431        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
3432        undocumented: JsonObject,
3433    },
3434    #[serde(untagged)]
3435    Undocumented(JsonObject),
3436}
3437
3438impl StoreError {
3439    pub fn is_duplicate_name(&self) -> bool {
3440        matches!(self, Self::DuplicateName)
3441    }
3442    pub fn user_not_found(&self) -> Option<&i64> {
3443        if let Self::UserNotFound { user_id, .. } = self {
3444            Some(user_id)
3445        } else {
3446            None
3447        }
3448    }
3449    pub fn is_relay_user_not_found(&self) -> bool {
3450        matches!(self, Self::RelayUserNotFound)
3451    }
3452    pub fn user_not_found_by_name(&self) -> Option<&String> {
3453        if let Self::UserNotFoundByName { contact_name, .. } = self {
3454            Some(contact_name)
3455        } else {
3456            None
3457        }
3458    }
3459    pub fn user_not_found_by_contact_id(&self) -> Option<&i64> {
3460        if let Self::UserNotFoundByContactId { contact_id, .. } = self {
3461            Some(contact_id)
3462        } else {
3463            None
3464        }
3465    }
3466    pub fn user_not_found_by_group_id(&self) -> Option<&i64> {
3467        if let Self::UserNotFoundByGroupId { group_id, .. } = self {
3468            Some(group_id)
3469        } else {
3470            None
3471        }
3472    }
3473    pub fn user_not_found_by_file_id(&self) -> Option<&i64> {
3474        if let Self::UserNotFoundByFileId { file_id, .. } = self {
3475            Some(file_id)
3476        } else {
3477            None
3478        }
3479    }
3480    pub fn user_not_found_by_contact_request_id(&self) -> Option<&i64> {
3481        if let Self::UserNotFoundByContactRequestId {
3482            contact_request_id, ..
3483        } = self
3484        {
3485            Some(contact_request_id)
3486        } else {
3487            None
3488        }
3489    }
3490    pub fn contact_not_found(&self) -> Option<&i64> {
3491        if let Self::ContactNotFound { contact_id, .. } = self {
3492            Some(contact_id)
3493        } else {
3494            None
3495        }
3496    }
3497    pub fn contact_not_found_by_name(&self) -> Option<&String> {
3498        if let Self::ContactNotFoundByName { contact_name, .. } = self {
3499            Some(contact_name)
3500        } else {
3501            None
3502        }
3503    }
3504    pub fn contact_not_found_by_member_id(&self) -> Option<&i64> {
3505        if let Self::ContactNotFoundByMemberId {
3506            group_member_id, ..
3507        } = self
3508        {
3509            Some(group_member_id)
3510        } else {
3511            None
3512        }
3513    }
3514    pub fn contact_not_ready(&self) -> Option<&String> {
3515        if let Self::ContactNotReady { contact_name, .. } = self {
3516            Some(contact_name)
3517        } else {
3518            None
3519        }
3520    }
3521    pub fn is_duplicate_contact_link(&self) -> bool {
3522        matches!(self, Self::DuplicateContactLink)
3523    }
3524    pub fn is_user_contact_link_not_found(&self) -> bool {
3525        matches!(self, Self::UserContactLinkNotFound)
3526    }
3527    pub fn contact_request_not_found(&self) -> Option<&i64> {
3528        if let Self::ContactRequestNotFound {
3529            contact_request_id, ..
3530        } = self
3531        {
3532            Some(contact_request_id)
3533        } else {
3534            None
3535        }
3536    }
3537    pub fn contact_request_not_found_by_name(&self) -> Option<&String> {
3538        if let Self::ContactRequestNotFoundByName { contact_name, .. } = self {
3539            Some(contact_name)
3540        } else {
3541            None
3542        }
3543    }
3544    pub fn invalid_contact_request_entity(&self) -> Option<&i64> {
3545        if let Self::InvalidContactRequestEntity {
3546            contact_request_id, ..
3547        } = self
3548        {
3549            Some(contact_request_id)
3550        } else {
3551            None
3552        }
3553    }
3554    pub fn is_invalid_business_chat_contact_request(&self) -> bool {
3555        matches!(self, Self::InvalidBusinessChatContactRequest)
3556    }
3557    pub fn group_not_found(&self) -> Option<&i64> {
3558        if let Self::GroupNotFound { group_id, .. } = self {
3559            Some(group_id)
3560        } else {
3561            None
3562        }
3563    }
3564    pub fn group_not_found_by_name(&self) -> Option<&String> {
3565        if let Self::GroupNotFoundByName { group_name, .. } = self {
3566            Some(group_name)
3567        } else {
3568            None
3569        }
3570    }
3571    pub fn group_member_name_not_found(&self) -> Option<StoreErrorGroupMemberNameNotFoundRef<'_>> {
3572        if let Self::GroupMemberNameNotFound {
3573            group_id,
3574            group_member_name,
3575            ..
3576        } = self
3577        {
3578            Some(StoreErrorGroupMemberNameNotFoundRef {
3579                group_id,
3580                group_member_name,
3581            })
3582        } else {
3583            None
3584        }
3585    }
3586    pub fn group_member_not_found(&self) -> Option<&i64> {
3587        if let Self::GroupMemberNotFound {
3588            group_member_id, ..
3589        } = self
3590        {
3591            Some(group_member_id)
3592        } else {
3593            None
3594        }
3595    }
3596    pub fn group_member_not_found_by_index(&self) -> Option<&i64> {
3597        if let Self::GroupMemberNotFoundByIndex {
3598            group_member_index, ..
3599        } = self
3600        {
3601            Some(group_member_index)
3602        } else {
3603            None
3604        }
3605    }
3606    pub fn member_relations_vector_not_found(&self) -> Option<&i64> {
3607        if let Self::MemberRelationsVectorNotFound {
3608            group_member_id, ..
3609        } = self
3610        {
3611            Some(group_member_id)
3612        } else {
3613            None
3614        }
3615    }
3616    pub fn group_host_member_not_found(&self) -> Option<&i64> {
3617        if let Self::GroupHostMemberNotFound { group_id, .. } = self {
3618            Some(group_id)
3619        } else {
3620            None
3621        }
3622    }
3623    pub fn group_member_not_found_by_member_id(&self) -> Option<&String> {
3624        if let Self::GroupMemberNotFoundByMemberId { member_id, .. } = self {
3625            Some(member_id)
3626        } else {
3627            None
3628        }
3629    }
3630    pub fn member_contact_group_member_not_found(&self) -> Option<&i64> {
3631        if let Self::MemberContactGroupMemberNotFound { contact_id, .. } = self {
3632            Some(contact_id)
3633        } else {
3634            None
3635        }
3636    }
3637    pub fn is_invalid_member_relation_update(&self) -> bool {
3638        matches!(self, Self::InvalidMemberRelationUpdate)
3639    }
3640    pub fn is_group_without_user(&self) -> bool {
3641        matches!(self, Self::GroupWithoutUser)
3642    }
3643    pub fn is_duplicate_group_member(&self) -> bool {
3644        matches!(self, Self::DuplicateGroupMember)
3645    }
3646    pub fn is_duplicate_member_id(&self) -> bool {
3647        matches!(self, Self::DuplicateMemberId)
3648    }
3649    pub fn is_group_already_joined(&self) -> bool {
3650        matches!(self, Self::GroupAlreadyJoined)
3651    }
3652    pub fn is_group_invitation_not_found(&self) -> bool {
3653        matches!(self, Self::GroupInvitationNotFound)
3654    }
3655    pub fn note_folder_already_exists(&self) -> Option<&i64> {
3656        if let Self::NoteFolderAlreadyExists { note_folder_id, .. } = self {
3657            Some(note_folder_id)
3658        } else {
3659            None
3660        }
3661    }
3662    pub fn note_folder_not_found(&self) -> Option<&i64> {
3663        if let Self::NoteFolderNotFound { note_folder_id, .. } = self {
3664            Some(note_folder_id)
3665        } else {
3666            None
3667        }
3668    }
3669    pub fn is_user_note_folder_not_found(&self) -> bool {
3670        matches!(self, Self::UserNoteFolderNotFound)
3671    }
3672    pub fn snd_file_not_found(&self) -> Option<&i64> {
3673        if let Self::SndFileNotFound { file_id, .. } = self {
3674            Some(file_id)
3675        } else {
3676            None
3677        }
3678    }
3679    pub fn snd_file_invalid(&self) -> Option<&i64> {
3680        if let Self::SndFileInvalid { file_id, .. } = self {
3681            Some(file_id)
3682        } else {
3683            None
3684        }
3685    }
3686    pub fn rcv_file_not_found(&self) -> Option<&i64> {
3687        if let Self::RcvFileNotFound { file_id, .. } = self {
3688            Some(file_id)
3689        } else {
3690            None
3691        }
3692    }
3693    pub fn rcv_file_descr_not_found(&self) -> Option<&i64> {
3694        if let Self::RcvFileDescrNotFound { file_id, .. } = self {
3695            Some(file_id)
3696        } else {
3697            None
3698        }
3699    }
3700    pub fn file_not_found(&self) -> Option<&i64> {
3701        if let Self::FileNotFound { file_id, .. } = self {
3702            Some(file_id)
3703        } else {
3704            None
3705        }
3706    }
3707    pub fn rcv_file_invalid(&self) -> Option<&i64> {
3708        if let Self::RcvFileInvalid { file_id, .. } = self {
3709            Some(file_id)
3710        } else {
3711            None
3712        }
3713    }
3714    pub fn is_rcv_file_invalid_descr_part(&self) -> bool {
3715        matches!(self, Self::RcvFileInvalidDescrPart)
3716    }
3717    pub fn local_file_no_transfer(&self) -> Option<&i64> {
3718        if let Self::LocalFileNoTransfer { file_id, .. } = self {
3719            Some(file_id)
3720        } else {
3721            None
3722        }
3723    }
3724    pub fn shared_msg_id_not_found_by_file_id(&self) -> Option<&i64> {
3725        if let Self::SharedMsgIdNotFoundByFileId { file_id, .. } = self {
3726            Some(file_id)
3727        } else {
3728            None
3729        }
3730    }
3731    pub fn file_id_not_found_by_shared_msg_id(&self) -> Option<&String> {
3732        if let Self::FileIdNotFoundBySharedMsgId { shared_msg_id, .. } = self {
3733            Some(shared_msg_id)
3734        } else {
3735            None
3736        }
3737    }
3738    pub fn snd_file_not_found_xftp(&self) -> Option<&String> {
3739        if let Self::SndFileNotFoundXftp {
3740            agent_snd_file_id, ..
3741        } = self
3742        {
3743            Some(agent_snd_file_id)
3744        } else {
3745            None
3746        }
3747    }
3748    pub fn rcv_file_not_found_xftp(&self) -> Option<&String> {
3749        if let Self::RcvFileNotFoundXftp {
3750            agent_rcv_file_id, ..
3751        } = self
3752        {
3753            Some(agent_rcv_file_id)
3754        } else {
3755            None
3756        }
3757    }
3758    pub fn connection_not_found(&self) -> Option<&String> {
3759        if let Self::ConnectionNotFound { agent_conn_id, .. } = self {
3760            Some(agent_conn_id)
3761        } else {
3762            None
3763        }
3764    }
3765    pub fn connection_not_found_by_id(&self) -> Option<&i64> {
3766        if let Self::ConnectionNotFoundById { conn_id, .. } = self {
3767            Some(conn_id)
3768        } else {
3769            None
3770        }
3771    }
3772    pub fn connection_not_found_by_member_id(&self) -> Option<&i64> {
3773        if let Self::ConnectionNotFoundByMemberId {
3774            group_member_id, ..
3775        } = self
3776        {
3777            Some(group_member_id)
3778        } else {
3779            None
3780        }
3781    }
3782    pub fn pending_connection_not_found(&self) -> Option<&i64> {
3783        if let Self::PendingConnectionNotFound { conn_id, .. } = self {
3784            Some(conn_id)
3785        } else {
3786            None
3787        }
3788    }
3789    pub fn is_unique_id(&self) -> bool {
3790        matches!(self, Self::UniqueId)
3791    }
3792    pub fn is_large_msg(&self) -> bool {
3793        matches!(self, Self::LargeMsg)
3794    }
3795    pub fn internal_error(&self) -> Option<&String> {
3796        if let Self::InternalError { message, .. } = self {
3797            Some(message)
3798        } else {
3799            None
3800        }
3801    }
3802    pub fn db_exception(&self) -> Option<&String> {
3803        if let Self::DBException { message, .. } = self {
3804            Some(message)
3805        } else {
3806            None
3807        }
3808    }
3809    pub fn db_busy_error(&self) -> Option<&String> {
3810        if let Self::DBBusyError { message, .. } = self {
3811            Some(message)
3812        } else {
3813            None
3814        }
3815    }
3816    pub fn bad_chat_item(&self) -> Option<StoreErrorBadChatItemRef<'_>> {
3817        if let Self::BadChatItem {
3818            item_id, item_ts, ..
3819        } = self
3820        {
3821            Some(StoreErrorBadChatItemRef { item_id, item_ts })
3822        } else {
3823            None
3824        }
3825    }
3826    pub fn chat_item_not_found(&self) -> Option<&i64> {
3827        if let Self::ChatItemNotFound { item_id, .. } = self {
3828            Some(item_id)
3829        } else {
3830            None
3831        }
3832    }
3833    pub fn chat_item_not_found_by_text(&self) -> Option<&String> {
3834        if let Self::ChatItemNotFoundByText { text, .. } = self {
3835            Some(text)
3836        } else {
3837            None
3838        }
3839    }
3840    pub fn chat_item_shared_msg_id_not_found(&self) -> Option<&String> {
3841        if let Self::ChatItemSharedMsgIdNotFound { shared_msg_id, .. } = self {
3842            Some(shared_msg_id)
3843        } else {
3844            None
3845        }
3846    }
3847    pub fn chat_item_not_found_by_file_id(&self) -> Option<&i64> {
3848        if let Self::ChatItemNotFoundByFileId { file_id, .. } = self {
3849            Some(file_id)
3850        } else {
3851            None
3852        }
3853    }
3854    pub fn chat_item_not_found_by_contact_id(&self) -> Option<&i64> {
3855        if let Self::ChatItemNotFoundByContactId { contact_id, .. } = self {
3856            Some(contact_id)
3857        } else {
3858            None
3859        }
3860    }
3861    pub fn chat_item_not_found_by_group_id(&self) -> Option<&i64> {
3862        if let Self::ChatItemNotFoundByGroupId { group_id, .. } = self {
3863            Some(group_id)
3864        } else {
3865            None
3866        }
3867    }
3868    pub fn profile_not_found(&self) -> Option<&i64> {
3869        if let Self::ProfileNotFound { profile_id, .. } = self {
3870            Some(profile_id)
3871        } else {
3872            None
3873        }
3874    }
3875    pub fn duplicate_group_link(&self) -> Option<&GroupInfo> {
3876        if let Self::DuplicateGroupLink { group_info, .. } = self {
3877            Some(group_info)
3878        } else {
3879            None
3880        }
3881    }
3882    pub fn group_link_not_found(&self) -> Option<&GroupInfo> {
3883        if let Self::GroupLinkNotFound { group_info, .. } = self {
3884            Some(group_info)
3885        } else {
3886            None
3887        }
3888    }
3889    pub fn host_member_id_not_found(&self) -> Option<&i64> {
3890        if let Self::HostMemberIdNotFound { group_id, .. } = self {
3891            Some(group_id)
3892        } else {
3893            None
3894        }
3895    }
3896    pub fn contact_not_found_by_file_id(&self) -> Option<&i64> {
3897        if let Self::ContactNotFoundByFileId { file_id, .. } = self {
3898            Some(file_id)
3899        } else {
3900            None
3901        }
3902    }
3903    pub fn no_group_snd_status(&self) -> Option<StoreErrorNoGroupSndStatusRef<'_>> {
3904        if let Self::NoGroupSndStatus {
3905            item_id,
3906            group_member_id,
3907            ..
3908        } = self
3909        {
3910            Some(StoreErrorNoGroupSndStatusRef {
3911                item_id,
3912                group_member_id,
3913            })
3914        } else {
3915            None
3916        }
3917    }
3918    pub fn duplicate_group_message(&self) -> Option<StoreErrorDuplicateGroupMessageRef<'_>> {
3919        if let Self::DuplicateGroupMessage {
3920            group_id,
3921            shared_msg_id,
3922            author_group_member_id,
3923            forwarded_by_group_member_id,
3924            ..
3925        } = self
3926        {
3927            Some(StoreErrorDuplicateGroupMessageRef {
3928                group_id,
3929                shared_msg_id,
3930                author_group_member_id,
3931                forwarded_by_group_member_id,
3932            })
3933        } else {
3934            None
3935        }
3936    }
3937    pub fn remote_host_not_found(&self) -> Option<&i64> {
3938        if let Self::RemoteHostNotFound { remote_host_id, .. } = self {
3939            Some(remote_host_id)
3940        } else {
3941            None
3942        }
3943    }
3944    pub fn is_remote_host_unknown(&self) -> bool {
3945        matches!(self, Self::RemoteHostUnknown)
3946    }
3947    pub fn is_remote_host_duplicate_ca(&self) -> bool {
3948        matches!(self, Self::RemoteHostDuplicateCa)
3949    }
3950    pub fn remote_ctrl_not_found(&self) -> Option<&i64> {
3951        if let Self::RemoteCtrlNotFound { remote_ctrl_id, .. } = self {
3952            Some(remote_ctrl_id)
3953        } else {
3954            None
3955        }
3956    }
3957    pub fn is_remote_ctrl_duplicate_ca(&self) -> bool {
3958        matches!(self, Self::RemoteCtrlDuplicateCa)
3959    }
3960    pub fn prohibited_delete_user(&self) -> Option<StoreErrorProhibitedDeleteUserRef<'_>> {
3961        if let Self::ProhibitedDeleteUser {
3962            user_id,
3963            contact_id,
3964            ..
3965        } = self
3966        {
3967            Some(StoreErrorProhibitedDeleteUserRef {
3968                user_id,
3969                contact_id,
3970            })
3971        } else {
3972            None
3973        }
3974    }
3975    pub fn operator_not_found(&self) -> Option<&i64> {
3976        if let Self::OperatorNotFound {
3977            server_operator_id, ..
3978        } = self
3979        {
3980            Some(server_operator_id)
3981        } else {
3982            None
3983        }
3984    }
3985    pub fn is_usage_conditions_not_found(&self) -> bool {
3986        matches!(self, Self::UsageConditionsNotFound)
3987    }
3988    pub fn user_chat_relay_not_found(&self) -> Option<&i64> {
3989        if let Self::UserChatRelayNotFound { chat_relay_id, .. } = self {
3990            Some(chat_relay_id)
3991        } else {
3992            None
3993        }
3994    }
3995    pub fn group_relay_not_found(&self) -> Option<&i64> {
3996        if let Self::GroupRelayNotFound { group_relay_id, .. } = self {
3997            Some(group_relay_id)
3998        } else {
3999            None
4000        }
4001    }
4002    pub fn group_relay_not_found_by_member_id(&self) -> Option<&i64> {
4003        if let Self::GroupRelayNotFoundByMemberId {
4004            group_member_id, ..
4005        } = self
4006        {
4007            Some(group_member_id)
4008        } else {
4009            None
4010        }
4011    }
4012    pub fn is_invalid_quote(&self) -> bool {
4013        matches!(self, Self::InvalidQuote)
4014    }
4015    pub fn is_invalid_mention(&self) -> bool {
4016        matches!(self, Self::InvalidMention)
4017    }
4018    pub fn invalid_delivery_task(&self) -> Option<&i64> {
4019        if let Self::InvalidDeliveryTask { task_id, .. } = self {
4020            Some(task_id)
4021        } else {
4022            None
4023        }
4024    }
4025    pub fn delivery_task_not_found(&self) -> Option<&i64> {
4026        if let Self::DeliveryTaskNotFound { task_id, .. } = self {
4027            Some(task_id)
4028        } else {
4029            None
4030        }
4031    }
4032    pub fn invalid_delivery_job(&self) -> Option<&i64> {
4033        if let Self::InvalidDeliveryJob { job_id, .. } = self {
4034            Some(job_id)
4035        } else {
4036            None
4037        }
4038    }
4039    pub fn delivery_job_not_found(&self) -> Option<&i64> {
4040        if let Self::DeliveryJobNotFound { job_id, .. } = self {
4041            Some(job_id)
4042        } else {
4043            None
4044        }
4045    }
4046    pub fn work_item_error(&self) -> Option<&String> {
4047        if let Self::WorkItemError { err_context, .. } = self {
4048            Some(err_context)
4049        } else {
4050            None
4051        }
4052    }
4053}
4054#[derive(Clone, Copy)]
4055pub struct StoreErrorGroupMemberNameNotFoundRef<'a> {
4056    pub group_id: &'a i64,
4057    pub group_member_name: &'a String,
4058}
4059#[derive(Clone, Copy)]
4060pub struct StoreErrorBadChatItemRef<'a> {
4061    pub item_id: &'a i64,
4062    pub item_ts: &'a Option<UtcTime>,
4063}
4064#[derive(Clone, Copy)]
4065pub struct StoreErrorNoGroupSndStatusRef<'a> {
4066    pub item_id: &'a i64,
4067    pub group_member_id: &'a i64,
4068}
4069#[derive(Clone, Copy)]
4070pub struct StoreErrorDuplicateGroupMessageRef<'a> {
4071    pub group_id: &'a i64,
4072    pub shared_msg_id: &'a String,
4073    pub author_group_member_id: &'a Option<i64>,
4074    pub forwarded_by_group_member_id: &'a Option<i64>,
4075}
4076#[derive(Clone, Copy)]
4077pub struct StoreErrorProhibitedDeleteUserRef<'a> {
4078    pub user_id: &'a i64,
4079    pub contact_id: &'a i64,
4080}
4081
4082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4083#[serde(tag = "type")]
4084#[non_exhaustive]
4085pub enum TransportError {
4086    #[serde(rename = "badBlock")]
4087    BadBlock,
4088    #[serde(rename = "version")]
4089    Version,
4090    #[serde(rename = "largeMsg")]
4091    LargeMsg,
4092    #[serde(rename = "badSession")]
4093    BadSession,
4094    #[serde(rename = "noServerAuth")]
4095    NoServerAuth,
4096    #[serde(rename = "handshake")]
4097    Handshake {
4098        #[serde(rename = "handshakeErr")]
4099        handshake_err: HandshakeError,
4100
4101        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
4102        undocumented: JsonObject,
4103    },
4104    #[serde(untagged)]
4105    Undocumented(JsonObject),
4106}
4107
4108impl TransportError {
4109    pub fn is_bad_block(&self) -> bool {
4110        matches!(self, Self::BadBlock)
4111    }
4112    pub fn is_version(&self) -> bool {
4113        matches!(self, Self::Version)
4114    }
4115    pub fn is_large_msg(&self) -> bool {
4116        matches!(self, Self::LargeMsg)
4117    }
4118    pub fn is_bad_session(&self) -> bool {
4119        matches!(self, Self::BadSession)
4120    }
4121    pub fn is_no_server_auth(&self) -> bool {
4122        matches!(self, Self::NoServerAuth)
4123    }
4124    pub fn handshake(&self) -> Option<&HandshakeError> {
4125        if let Self::Handshake { handshake_err, .. } = self {
4126            Some(handshake_err)
4127        } else {
4128            None
4129        }
4130    }
4131}
4132
4133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4134#[serde(tag = "type")]
4135#[non_exhaustive]
4136pub enum XFTPErrorType {
4137    #[serde(rename = "BLOCK")]
4138    Block,
4139    #[serde(rename = "SESSION")]
4140    Session,
4141    #[serde(rename = "HANDSHAKE")]
4142    Handshake,
4143    #[serde(rename = "CMD")]
4144    Cmd {
4145        #[serde(rename = "cmdErr")]
4146        cmd_err: CommandError,
4147
4148        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
4149        undocumented: JsonObject,
4150    },
4151    #[serde(rename = "AUTH")]
4152    Auth,
4153    #[serde(rename = "BLOCKED")]
4154    Blocked {
4155        #[serde(rename = "blockInfo")]
4156        block_info: BlockingInfo,
4157
4158        #[serde(flatten, skip_serializing_if = "JsonObject::is_null")]
4159        undocumented: JsonObject,
4160    },
4161    #[serde(rename = "SIZE")]
4162    Size,
4163    #[serde(rename = "QUOTA")]
4164    Quota,
4165    #[serde(rename = "DIGEST")]
4166    Digest,
4167    #[serde(rename = "CRYPTO")]
4168    Crypto,
4169    #[serde(rename = "NO_FILE")]
4170    NoFile,
4171    #[serde(rename = "HAS_FILE")]
4172    HasFile,
4173    #[serde(rename = "FILE_IO")]
4174    FileIo,
4175    #[serde(rename = "TIMEOUT")]
4176    Timeout,
4177    #[serde(rename = "INTERNAL")]
4178    Internal,
4179    #[serde(rename = "DUPLICATE_")]
4180    Duplicate,
4181    #[serde(untagged)]
4182    Undocumented(JsonObject),
4183}
4184
4185impl XFTPErrorType {
4186    pub fn is_block(&self) -> bool {
4187        matches!(self, Self::Block)
4188    }
4189    pub fn is_session(&self) -> bool {
4190        matches!(self, Self::Session)
4191    }
4192    pub fn is_handshake(&self) -> bool {
4193        matches!(self, Self::Handshake)
4194    }
4195    pub fn cmd(&self) -> Option<&CommandError> {
4196        if let Self::Cmd { cmd_err, .. } = self {
4197            Some(cmd_err)
4198        } else {
4199            None
4200        }
4201    }
4202    pub fn is_auth(&self) -> bool {
4203        matches!(self, Self::Auth)
4204    }
4205    pub fn blocked(&self) -> Option<&BlockingInfo> {
4206        if let Self::Blocked { block_info, .. } = self {
4207            Some(block_info)
4208        } else {
4209            None
4210        }
4211    }
4212    pub fn is_size(&self) -> bool {
4213        matches!(self, Self::Size)
4214    }
4215    pub fn is_quota(&self) -> bool {
4216        matches!(self, Self::Quota)
4217    }
4218    pub fn is_digest(&self) -> bool {
4219        matches!(self, Self::Digest)
4220    }
4221    pub fn is_crypto(&self) -> bool {
4222        matches!(self, Self::Crypto)
4223    }
4224    pub fn is_no_file(&self) -> bool {
4225        matches!(self, Self::NoFile)
4226    }
4227    pub fn is_has_file(&self) -> bool {
4228        matches!(self, Self::HasFile)
4229    }
4230    pub fn is_file_io(&self) -> bool {
4231        matches!(self, Self::FileIo)
4232    }
4233    pub fn is_timeout(&self) -> bool {
4234        matches!(self, Self::Timeout)
4235    }
4236    pub fn is_internal(&self) -> bool {
4237        matches!(self, Self::Internal)
4238    }
4239    pub fn is_duplicate(&self) -> bool {
4240        matches!(self, Self::Duplicate)
4241    }
4242}
4243
4244macro_rules! impl_error {
4245    ($($t:ty),+ $(,)?) => (
4246        $(
4247        impl std::fmt::Display for $t {
4248            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4249                write!(f, "{:#?}", self)
4250            }
4251        }
4252
4253        impl std::error::Error for $t {}
4254        )+
4255    );
4256}
4257
4258impl_error!(
4259    AgentCryptoError,
4260    AgentErrorType,
4261    BrokerErrorType,
4262    ChatError,
4263    ChatErrorType,
4264    CommandError,
4265    CommandErrorType,
4266    ConnectionErrorType,
4267    ErrorType,
4268    FileError,
4269    FileErrorType,
4270    HandshakeError,
4271    MsgDecryptError,
4272    MsgErrorType,
4273    NetworkError,
4274    ProxyClientError,
4275    ProxyError,
4276    RCErrorType,
4277    RcvMsgError,
4278    SMPAgentError,
4279    SndError,
4280    SrvError,
4281    StoreError,
4282    TransportError,
4283    XFTPErrorType
4284);