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::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 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 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}