Skip to main content

muse_code_sdk/msp/view/item_content/
catch_all.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use super::{
4    CompactionOutcome, CompactionTrigger, HookRunStatus, ItemKind, ItemStatus,
5    OutputRefAvailability, SubagentControlStatus,
6};
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8
9impl OutputRefAvailability {
10    /// The exact wire spelling, including an unknown word kept verbatim.
11    pub fn as_str(&self) -> &str {
12        match self {
13            Self::Available => "available",
14            Self::Missing => "missing",
15            Self::Unsupported => "unsupported",
16            Self::AccessFailed => "accessFailed",
17            Self::Unknown(word) => word,
18        }
19    }
20}
21
22impl Serialize for OutputRefAvailability {
23    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
24        serializer.serialize_str(self.as_str())
25    }
26}
27
28impl<'de> Deserialize<'de> for OutputRefAvailability {
29    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
30        let word = String::deserialize(deserializer)?;
31        Ok(match word.as_str() {
32            "available" => Self::Available,
33            "missing" => Self::Missing,
34            "unsupported" => Self::Unsupported,
35            "accessFailed" => Self::AccessFailed,
36            _ => Self::Unknown(word),
37        })
38    }
39}
40
41impl SubagentControlStatus {
42    /// The exact wire spelling, including an unknown word kept verbatim.
43    pub fn as_str(&self) -> &str {
44        match self {
45            Self::Accepted => "accepted",
46            Self::Starting => "starting",
47            Self::Running => "running",
48            Self::ResultReady => "resultReady",
49            Self::Closing => "closing",
50            Self::Closed => "closed",
51            Self::RecoveryPending => "recoveryPending",
52            Self::ManualReconciliation => "manualReconciliation",
53            Self::Unknown(word) => word,
54        }
55    }
56}
57
58impl Serialize for SubagentControlStatus {
59    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
60        serializer.serialize_str(self.as_str())
61    }
62}
63
64impl<'de> Deserialize<'de> for SubagentControlStatus {
65    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
66        let word = String::deserialize(deserializer)?;
67        Ok(match word.as_str() {
68            "accepted" => Self::Accepted,
69            "starting" => Self::Starting,
70            "running" => Self::Running,
71            "resultReady" => Self::ResultReady,
72            "closing" => Self::Closing,
73            "closed" => Self::Closed,
74            "recoveryPending" => Self::RecoveryPending,
75            "manualReconciliation" => Self::ManualReconciliation,
76            _ => Self::Unknown(word),
77        })
78    }
79}
80
81impl CompactionOutcome {
82    /// The exact wire spelling, including an unknown word kept verbatim.
83    pub fn as_str(&self) -> &str {
84        match self {
85            Self::Compacted => "compacted",
86            Self::Noop => "noop",
87            Self::Failed => "failed",
88            Self::Cancelled => "cancelled",
89            Self::Unknown(word) => word,
90        }
91    }
92}
93
94impl Serialize for CompactionOutcome {
95    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
96        serializer.serialize_str(self.as_str())
97    }
98}
99
100impl<'de> Deserialize<'de> for CompactionOutcome {
101    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
102        let word = String::deserialize(deserializer)?;
103        Ok(match word.as_str() {
104            "compacted" => Self::Compacted,
105            "noop" => Self::Noop,
106            "failed" => Self::Failed,
107            "cancelled" => Self::Cancelled,
108            _ => Self::Unknown(word),
109        })
110    }
111}
112
113impl CompactionTrigger {
114    /// The exact wire spelling, including an unknown word kept verbatim.
115    pub fn as_str(&self) -> &str {
116        match self {
117            Self::Manual => "manual",
118            Self::Auto => "auto",
119            Self::Unknown(word) => word,
120        }
121    }
122}
123
124impl Serialize for CompactionTrigger {
125    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
126        serializer.serialize_str(self.as_str())
127    }
128}
129
130impl<'de> Deserialize<'de> for CompactionTrigger {
131    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
132        let word = String::deserialize(deserializer)?;
133        Ok(match word.as_str() {
134            "manual" => Self::Manual,
135            "auto" => Self::Auto,
136            _ => Self::Unknown(word),
137        })
138    }
139}
140
141impl ItemKind {
142    /// The exact wire spelling, including an unknown word kept verbatim.
143    pub fn as_str(&self) -> &str {
144        match self {
145            Self::UserMessage => "userMessage",
146            Self::AgentMessage => "agentMessage",
147            Self::Reasoning => "reasoning",
148            Self::ToolCall => "toolCall",
149            Self::UserShell => "userShell",
150            Self::Subagent => "subagent",
151            Self::Workflow => "workflow",
152            Self::ReminderChild => "reminderChild",
153            Self::Compaction => "compaction",
154            Self::HookRun => "hookRun",
155            Self::SideChat => "sideChat",
156            Self::SkillRead => "skillRead",
157            Self::WebSearch => "webSearch",
158            Self::MonitorFeed => "monitorFeed",
159            Self::DamagedRange => "damagedRange",
160            Self::ScheduledFire => "scheduledFire",
161            Self::BackgroundTerminalCompletion => "backgroundTerminalCompletion",
162            Self::OverdueNotice => "overdueNotice",
163            Self::EarlierHistory => "earlierHistory",
164            Self::Unknown(word) => word,
165        }
166    }
167}
168
169impl Serialize for ItemKind {
170    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
171        serializer.serialize_str(self.as_str())
172    }
173}
174
175impl<'de> Deserialize<'de> for ItemKind {
176    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
177        let word = String::deserialize(deserializer)?;
178        Ok(match word.as_str() {
179            "userMessage" => Self::UserMessage,
180            "agentMessage" => Self::AgentMessage,
181            "reasoning" => Self::Reasoning,
182            "toolCall" => Self::ToolCall,
183            "userShell" => Self::UserShell,
184            "subagent" => Self::Subagent,
185            "workflow" => Self::Workflow,
186            "reminderChild" => Self::ReminderChild,
187            "compaction" => Self::Compaction,
188            "hookRun" => Self::HookRun,
189            "sideChat" => Self::SideChat,
190            "skillRead" => Self::SkillRead,
191            "webSearch" => Self::WebSearch,
192            "monitorFeed" => Self::MonitorFeed,
193            "damagedRange" => Self::DamagedRange,
194            "scheduledFire" => Self::ScheduledFire,
195            "backgroundTerminalCompletion" => Self::BackgroundTerminalCompletion,
196            "overdueNotice" => Self::OverdueNotice,
197            "earlierHistory" => Self::EarlierHistory,
198            _ => Self::Unknown(word),
199        })
200    }
201}
202
203impl ItemStatus {
204    /// The exact wire spelling, including an unknown word kept verbatim.
205    pub fn as_str(&self) -> &str {
206        match self {
207            Self::InProgress => "inProgress",
208            Self::Completed => "completed",
209            Self::Failed => "failed",
210            Self::Cancelled => "cancelled",
211            Self::Rejected => "rejected",
212            Self::TimedOut => "timedOut",
213            Self::Unknown(word) => word,
214        }
215    }
216}
217
218impl Serialize for ItemStatus {
219    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
220        serializer.serialize_str(self.as_str())
221    }
222}
223
224impl<'de> Deserialize<'de> for ItemStatus {
225    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
226        let word = String::deserialize(deserializer)?;
227        Ok(match word.as_str() {
228            "inProgress" => Self::InProgress,
229            "completed" => Self::Completed,
230            "failed" => Self::Failed,
231            "cancelled" => Self::Cancelled,
232            "rejected" => Self::Rejected,
233            "timedOut" => Self::TimedOut,
234            _ => Self::Unknown(word),
235        })
236    }
237}
238
239impl HookRunStatus {
240    /// The exact wire spelling, including an unknown word kept verbatim.
241    pub fn as_str(&self) -> &str {
242        match self {
243            Self::Completed => "completed",
244            Self::Blocked => "blocked",
245            Self::Failed => "failed",
246            Self::TimedOut => "timedOut",
247            Self::Cancelled => "cancelled",
248            Self::Unknown(word) => word,
249        }
250    }
251}
252
253impl Serialize for HookRunStatus {
254    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
255        serializer.serialize_str(self.as_str())
256    }
257}
258
259impl<'de> Deserialize<'de> for HookRunStatus {
260    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
261        let word = String::deserialize(deserializer)?;
262        Ok(match word.as_str() {
263            "completed" => Self::Completed,
264            "blocked" => Self::Blocked,
265            "failed" => Self::Failed,
266            "timedOut" => Self::TimedOut,
267            "cancelled" => Self::Cancelled,
268            _ => Self::Unknown(word),
269        })
270    }
271}