Skip to main content

muse_code_sdk/msp/method/
session_wire_words.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use super::session::RunningElsewhereOrigin;
4use super::session::SessionKind;
5use super::session_events::SessionClosedReason;
6use super::session_events::SessionStatus;
7use serde::Deserialize;
8use serde::Deserializer;
9use serde::Serialize;
10use serde::Serializer;
11
12impl SessionKind {
13    /// The exact wire spelling, including a value from a newer host.
14    #[must_use]
15    pub fn as_str(&self) -> &str {
16        match self {
17            Self::Root => "root",
18            Self::Subagent => "subagent",
19            Self::Unknown(value) => value,
20        }
21    }
22}
23
24impl Serialize for SessionKind {
25    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
26    where
27        S: Serializer,
28    {
29        serializer.serialize_str(self.as_str())
30    }
31}
32
33impl<'de> Deserialize<'de> for SessionKind {
34    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
35    where
36        D: Deserializer<'de>,
37    {
38        let value = String::deserialize(deserializer)?;
39        Ok(match value.as_str() {
40            "root" => Self::Root,
41            "subagent" => Self::Subagent,
42            _ => Self::Unknown(value),
43        })
44    }
45}
46
47impl SessionStatus {
48    /// The exact wire spelling, including a value from a newer host.
49    #[must_use]
50    pub fn as_str(&self) -> &str {
51        match self {
52            Self::NotLoaded => "notLoaded",
53            Self::Idle => "idle",
54            Self::Running => "running",
55            Self::Unknown(value) => value,
56        }
57    }
58}
59
60impl Serialize for SessionStatus {
61    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
62    where
63        S: Serializer,
64    {
65        serializer.serialize_str(self.as_str())
66    }
67}
68
69impl<'de> Deserialize<'de> for SessionStatus {
70    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71    where
72        D: Deserializer<'de>,
73    {
74        let value = String::deserialize(deserializer)?;
75        Ok(match value.as_str() {
76            "notLoaded" => Self::NotLoaded,
77            "idle" => Self::Idle,
78            "running" => Self::Running,
79            _ => Self::Unknown(value),
80        })
81    }
82}
83
84impl SessionClosedReason {
85    /// The exact wire spelling, including a value from a newer host.
86    #[must_use]
87    pub fn as_str(&self) -> &str {
88        match self {
89            Self::Idle => "idle",
90            Self::HostShutdown => "hostShutdown",
91            Self::Leave => "leave",
92            Self::Vacated => "vacated",
93            Self::Unknown(value) => value,
94        }
95    }
96}
97
98impl Serialize for SessionClosedReason {
99    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
100    where
101        S: Serializer,
102    {
103        serializer.serialize_str(self.as_str())
104    }
105}
106
107impl<'de> Deserialize<'de> for SessionClosedReason {
108    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
109    where
110        D: Deserializer<'de>,
111    {
112        let value = String::deserialize(deserializer)?;
113        Ok(match value.as_str() {
114            "idle" => Self::Idle,
115            "hostShutdown" => Self::HostShutdown,
116            "leave" => Self::Leave,
117            "vacated" => Self::Vacated,
118            _ => Self::Unknown(value),
119        })
120    }
121}
122
123impl RunningElsewhereOrigin {
124    /// The exact wire spelling, including a value from a newer host.
125    #[must_use]
126    pub fn as_str(&self) -> &str {
127        match self {
128            Self::Tui => "tui",
129            Self::Exec => "exec",
130            Self::Serve => "serve",
131            Self::Unknown(value) => value,
132        }
133    }
134}
135
136impl Serialize for RunningElsewhereOrigin {
137    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
138    where
139        S: Serializer,
140    {
141        serializer.serialize_str(self.as_str())
142    }
143}
144
145impl<'de> Deserialize<'de> for RunningElsewhereOrigin {
146    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
147    where
148        D: Deserializer<'de>,
149    {
150        let value = String::deserialize(deserializer)?;
151        Ok(match value.as_str() {
152            "tui" => Self::Tui,
153            "exec" => Self::Exec,
154            "serve" => Self::Serve,
155            _ => Self::Unknown(value),
156        })
157    }
158}