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::Unknown(word) => word,
162        }
163    }
164}
165
166impl Serialize for ItemKind {
167    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
168        serializer.serialize_str(self.as_str())
169    }
170}
171
172impl<'de> Deserialize<'de> for ItemKind {
173    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
174        let word = String::deserialize(deserializer)?;
175        Ok(match word.as_str() {
176            "userMessage" => Self::UserMessage,
177            "agentMessage" => Self::AgentMessage,
178            "reasoning" => Self::Reasoning,
179            "toolCall" => Self::ToolCall,
180            "userShell" => Self::UserShell,
181            "subagent" => Self::Subagent,
182            "workflow" => Self::Workflow,
183            "reminderChild" => Self::ReminderChild,
184            "compaction" => Self::Compaction,
185            "hookRun" => Self::HookRun,
186            "sideChat" => Self::SideChat,
187            "skillRead" => Self::SkillRead,
188            "webSearch" => Self::WebSearch,
189            "monitorFeed" => Self::MonitorFeed,
190            "damagedRange" => Self::DamagedRange,
191            "scheduledFire" => Self::ScheduledFire,
192            _ => Self::Unknown(word),
193        })
194    }
195}
196
197impl ItemStatus {
198    /// The exact wire spelling, including an unknown word kept verbatim.
199    pub fn as_str(&self) -> &str {
200        match self {
201            Self::InProgress => "inProgress",
202            Self::Completed => "completed",
203            Self::Failed => "failed",
204            Self::Cancelled => "cancelled",
205            Self::Rejected => "rejected",
206            Self::TimedOut => "timedOut",
207            Self::Unknown(word) => word,
208        }
209    }
210}
211
212impl Serialize for ItemStatus {
213    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
214        serializer.serialize_str(self.as_str())
215    }
216}
217
218impl<'de> Deserialize<'de> for ItemStatus {
219    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
220        let word = String::deserialize(deserializer)?;
221        Ok(match word.as_str() {
222            "inProgress" => Self::InProgress,
223            "completed" => Self::Completed,
224            "failed" => Self::Failed,
225            "cancelled" => Self::Cancelled,
226            "rejected" => Self::Rejected,
227            "timedOut" => Self::TimedOut,
228            _ => Self::Unknown(word),
229        })
230    }
231}
232
233impl HookRunStatus {
234    /// The exact wire spelling, including an unknown word kept verbatim.
235    pub fn as_str(&self) -> &str {
236        match self {
237            Self::Completed => "completed",
238            Self::Blocked => "blocked",
239            Self::Failed => "failed",
240            Self::TimedOut => "timedOut",
241            Self::Cancelled => "cancelled",
242            Self::Unknown(word) => word,
243        }
244    }
245}
246
247impl Serialize for HookRunStatus {
248    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
249        serializer.serialize_str(self.as_str())
250    }
251}
252
253impl<'de> Deserialize<'de> for HookRunStatus {
254    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
255        let word = String::deserialize(deserializer)?;
256        Ok(match word.as_str() {
257            "completed" => Self::Completed,
258            "blocked" => Self::Blocked,
259            "failed" => Self::Failed,
260            "timedOut" => Self::TimedOut,
261            "cancelled" => Self::Cancelled,
262            _ => Self::Unknown(word),
263        })
264    }
265}