Skip to main content

muse_code_sdk/msp/method/lifecycle/
recovery.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use serde::Deserialize;
4use serde::Serialize;
5
6/// A requested construction choice; omission is distinct from explicit OFF.
7#[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/// A proven mode or unknown; future strings cannot establish OFF.
29#[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/// Proven effective-choice provenance, independently of input presence.
56#[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/// This construction's assessment, never an operation acceptance receipt.
87#[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/// One coherent producer snapshot; all members are required and non-null.
116#[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}