muse_code_sdk/msp/method/lifecycle/
recovery.rs1use serde::Deserialize;
4use serde::Serialize;
5
6#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
8#[serde(rename_all = "camelCase")]
9pub enum RecoveryMode {
10 On,
11 Off,
12}
13
14impl<'de> Deserialize<'de> for RecoveryMode {
15 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
16 where
17 D: serde::Deserializer<'de>,
18 {
19 let word = String::deserialize(deserializer)?;
20 match word.as_str() {
21 "on" => Ok(Self::On),
22 "off" => Ok(Self::Off),
23 _ => Err(serde::de::Error::unknown_variant(&word, &["on", "off"])),
24 }
25 }
26}
27
28#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
30#[serde(rename_all = "camelCase")]
31#[non_exhaustive]
32pub enum RecoveryObservedMode {
33 On,
34 Off,
35 Unknown,
36 #[serde(untagged)]
37 Unrecognized(String),
38}
39
40impl<'de> Deserialize<'de> for RecoveryObservedMode {
41 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
42 where
43 D: serde::Deserializer<'de>,
44 {
45 let word = String::deserialize(deserializer)?;
46 Ok(match word.as_str() {
47 "on" => Self::On,
48 "off" => Self::Off,
49 "unknown" => Self::Unknown,
50 _ => Self::Unrecognized(word),
51 })
52 }
53}
54
55#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
57#[serde(rename_all = "camelCase")]
58#[non_exhaustive]
59pub enum RecoveryEffectiveSource {
60 Request,
61 Retained,
62 LegacyOmission,
63 HostPolicy,
64 Unknown,
65 #[serde(untagged)]
66 Unrecognized(String),
67}
68
69impl<'de> Deserialize<'de> for RecoveryEffectiveSource {
70 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71 where
72 D: serde::Deserializer<'de>,
73 {
74 let word = String::deserialize(deserializer)?;
75 Ok(match word.as_str() {
76 "request" => Self::Request,
77 "retained" => Self::Retained,
78 "legacyOmission" => Self::LegacyOmission,
79 "hostPolicy" => Self::HostPolicy,
80 "unknown" => Self::Unknown,
81 _ => Self::Unrecognized(word),
82 })
83 }
84}
85
86#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
88#[serde(rename_all = "camelCase")]
89#[non_exhaustive]
90pub enum RecoveryQualification {
91 Qualified,
92 Unavailable,
93 NotRequired,
94 Unknown,
95 #[serde(untagged)]
96 Unrecognized(String),
97}
98
99impl<'de> Deserialize<'de> for RecoveryQualification {
100 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
101 where
102 D: serde::Deserializer<'de>,
103 {
104 let word = String::deserialize(deserializer)?;
105 Ok(match word.as_str() {
106 "qualified" => Self::Qualified,
107 "unavailable" => Self::Unavailable,
108 "notRequired" => Self::NotRequired,
109 "unknown" => Self::Unknown,
110 _ => Self::Unrecognized(word),
111 })
112 }
113}
114
115#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
117#[serde(rename_all = "camelCase")]
118#[non_exhaustive]
119pub struct RecoveryObservation {
120 pub session_id: String,
121 pub construction_id: String,
122 pub requested_mode: RecoveryObservedMode,
123 pub effective_mode: RecoveryObservedMode,
124 pub effective_source: RecoveryEffectiveSource,
125 pub qualification: RecoveryQualification,
126}