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::SessionKind;
4use super::session_events::SessionClosedReason;
5use super::session_events::SessionStatus;
6use serde::Deserialize;
7use serde::Deserializer;
8use serde::Serialize;
9use serde::Serializer;
10
11impl SessionKind {
12    /// The exact wire spelling, including a value from a newer host.
13    #[must_use]
14    pub fn as_str(&self) -> &str {
15        match self {
16            Self::Root => "root",
17            Self::Subagent => "subagent",
18            Self::Unknown(value) => value,
19        }
20    }
21}
22
23impl Serialize for SessionKind {
24    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
25    where
26        S: Serializer,
27    {
28        serializer.serialize_str(self.as_str())
29    }
30}
31
32impl<'de> Deserialize<'de> for SessionKind {
33    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
34    where
35        D: Deserializer<'de>,
36    {
37        let value = String::deserialize(deserializer)?;
38        Ok(match value.as_str() {
39            "root" => Self::Root,
40            "subagent" => Self::Subagent,
41            _ => Self::Unknown(value),
42        })
43    }
44}
45
46impl SessionStatus {
47    /// The exact wire spelling, including a value from a newer host.
48    #[must_use]
49    pub fn as_str(&self) -> &str {
50        match self {
51            Self::NotLoaded => "notLoaded",
52            Self::Idle => "idle",
53            Self::Running => "running",
54            Self::Unknown(value) => value,
55        }
56    }
57}
58
59impl Serialize for SessionStatus {
60    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
61    where
62        S: Serializer,
63    {
64        serializer.serialize_str(self.as_str())
65    }
66}
67
68impl<'de> Deserialize<'de> for SessionStatus {
69    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
70    where
71        D: Deserializer<'de>,
72    {
73        let value = String::deserialize(deserializer)?;
74        Ok(match value.as_str() {
75            "notLoaded" => Self::NotLoaded,
76            "idle" => Self::Idle,
77            "running" => Self::Running,
78            _ => Self::Unknown(value),
79        })
80    }
81}
82
83impl SessionClosedReason {
84    /// The exact wire spelling, including a value from a newer host.
85    #[must_use]
86    pub fn as_str(&self) -> &str {
87        match self {
88            Self::Idle => "idle",
89            Self::HostShutdown => "hostShutdown",
90            Self::Leave => "leave",
91            Self::Unknown(value) => value,
92        }
93    }
94}
95
96impl Serialize for SessionClosedReason {
97    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
98    where
99        S: Serializer,
100    {
101        serializer.serialize_str(self.as_str())
102    }
103}
104
105impl<'de> Deserialize<'de> for SessionClosedReason {
106    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
107    where
108        D: Deserializer<'de>,
109    {
110        let value = String::deserialize(deserializer)?;
111        Ok(match value.as_str() {
112            "idle" => Self::Idle,
113            "hostShutdown" => Self::HostShutdown,
114            "leave" => Self::Leave,
115            _ => Self::Unknown(value),
116        })
117    }
118}