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