Skip to main content

muse_code_sdk/msp/view/item_kind/
catch_all.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use super::{HookRunStatus, ItemKind, ItemStatus};
4use serde::{Deserialize, Deserializer, Serialize, Serializer};
5
6impl ItemKind {
7    /// The exact wire spelling, including an unknown word kept verbatim.
8    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    /// The exact wire spelling, including an unknown word kept verbatim.
80    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    /// The exact wire spelling, including an unknown word kept verbatim.
116    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}