muse_code_sdk/msp/view/item_kind/
catch_all.rs1use super::{HookRunStatus, ItemKind, ItemStatus};
4use serde::{Deserialize, Deserializer, Serialize, Serializer};
5
6impl ItemKind {
7 pub fn as_str(&self) -> &str {
9 match self {
10 Self::UserMessage => "userMessage",
11 Self::AgentMessage => "agentMessage",
12 Self::Reasoning => "reasoning",
13 Self::ToolCall => "toolCall",
14 Self::UserShell => "userShell",
15 Self::Subagent => "subagent",
16 Self::Workflow => "workflow",
17 Self::ReminderChild => "reminderChild",
18 Self::Compaction => "compaction",
19 Self::HookRun => "hookRun",
20 Self::SideChat => "sideChat",
21 Self::SkillRead => "skillRead",
22 Self::WebSearch => "webSearch",
23 Self::MonitorFeed => "monitorFeed",
24 Self::DamagedRange => "damagedRange",
25 Self::ScheduledFire => "scheduledFire",
26 Self::BackgroundTerminalCompletion => "backgroundTerminalCompletion",
27 Self::OverdueNotice => "overdueNotice",
28 Self::EarlierHistory => "earlierHistory",
29 Self::PeerMessage => "peerMessage",
30 Self::SubagentInput => "subagentInput",
31 Self::SubagentResult => "subagentResult",
32 Self::SystemNotice => "systemNotice",
33 Self::BodyCompletion => "bodyCompletion",
34 Self::Unknown(word) => word,
35 }
36 }
37}
38
39impl Serialize for ItemKind {
40 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
41 serializer.serialize_str(self.as_str())
42 }
43}
44
45impl<'de> Deserialize<'de> for ItemKind {
46 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
47 let word = String::deserialize(deserializer)?;
48 Ok(match word.as_str() {
49 "userMessage" => Self::UserMessage,
50 "agentMessage" => Self::AgentMessage,
51 "reasoning" => Self::Reasoning,
52 "toolCall" => Self::ToolCall,
53 "userShell" => Self::UserShell,
54 "subagent" => Self::Subagent,
55 "workflow" => Self::Workflow,
56 "reminderChild" => Self::ReminderChild,
57 "compaction" => Self::Compaction,
58 "hookRun" => Self::HookRun,
59 "sideChat" => Self::SideChat,
60 "skillRead" => Self::SkillRead,
61 "webSearch" => Self::WebSearch,
62 "monitorFeed" => Self::MonitorFeed,
63 "damagedRange" => Self::DamagedRange,
64 "scheduledFire" => Self::ScheduledFire,
65 "backgroundTerminalCompletion" => Self::BackgroundTerminalCompletion,
66 "overdueNotice" => Self::OverdueNotice,
67 "earlierHistory" => Self::EarlierHistory,
68 "peerMessage" => Self::PeerMessage,
69 "subagentInput" => Self::SubagentInput,
70 "subagentResult" => Self::SubagentResult,
71 "systemNotice" => Self::SystemNotice,
72 "bodyCompletion" => Self::BodyCompletion,
73 _ => Self::Unknown(word),
74 })
75 }
76}
77
78impl ItemStatus {
79 pub fn as_str(&self) -> &str {
81 match self {
82 Self::InProgress => "inProgress",
83 Self::Completed => "completed",
84 Self::Failed => "failed",
85 Self::Cancelled => "cancelled",
86 Self::Rejected => "rejected",
87 Self::TimedOut => "timedOut",
88 Self::Unknown(word) => word,
89 }
90 }
91}
92
93impl Serialize for ItemStatus {
94 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
95 serializer.serialize_str(self.as_str())
96 }
97}
98
99impl<'de> Deserialize<'de> for ItemStatus {
100 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
101 let word = String::deserialize(deserializer)?;
102 Ok(match word.as_str() {
103 "inProgress" => Self::InProgress,
104 "completed" => Self::Completed,
105 "failed" => Self::Failed,
106 "cancelled" => Self::Cancelled,
107 "rejected" => Self::Rejected,
108 "timedOut" => Self::TimedOut,
109 _ => Self::Unknown(word),
110 })
111 }
112}
113
114impl HookRunStatus {
115 pub fn as_str(&self) -> &str {
117 match self {
118 Self::Completed => "completed",
119 Self::Blocked => "blocked",
120 Self::Failed => "failed",
121 Self::TimedOut => "timedOut",
122 Self::Cancelled => "cancelled",
123 Self::Unknown(word) => word,
124 }
125 }
126}
127
128impl Serialize for HookRunStatus {
129 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
130 serializer.serialize_str(self.as_str())
131 }
132}
133
134impl<'de> Deserialize<'de> for HookRunStatus {
135 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
136 let word = String::deserialize(deserializer)?;
137 Ok(match word.as_str() {
138 "completed" => Self::Completed,
139 "blocked" => Self::Blocked,
140 "failed" => Self::Failed,
141 "timedOut" => Self::TimedOut,
142 "cancelled" => Self::Cancelled,
143 _ => Self::Unknown(word),
144 })
145 }
146}