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