muse_code_sdk/msp/view/item_content/
catch_all.rs1use super::{
4 CompactionOutcome, CompactionTrigger, HookRunStatus, ItemKind, ItemStatus,
5 OutputRefAvailability, SubagentControlStatus,
6};
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8
9impl OutputRefAvailability {
10 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 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 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 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 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 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 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}