Skip to main content

muse_code_sdk/msp/view/state/
catch_all.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use super::{ModelChangeSource, ReasoningEffortChangeSource, TodoStatus, Vcs};
4use serde::{Deserialize, Deserializer, Serialize, Serializer};
5
6impl ModelChangeSource {
7    /// The exact wire spelling, including an unknown word kept verbatim.
8    pub fn as_str(&self) -> &str {
9        match self {
10            Self::User => "user",
11            Self::Default => "default",
12            Self::Policy => "policy",
13            Self::Unknown(word) => word,
14        }
15    }
16}
17
18impl Serialize for ModelChangeSource {
19    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
20        serializer.serialize_str(self.as_str())
21    }
22}
23
24impl<'de> Deserialize<'de> for ModelChangeSource {
25    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
26        let word = String::deserialize(deserializer)?;
27        Ok(match word.as_str() {
28            "user" => Self::User,
29            "default" => Self::Default,
30            "policy" => Self::Policy,
31            _ => Self::Unknown(word),
32        })
33    }
34}
35
36impl ReasoningEffortChangeSource {
37    /// The exact wire spelling, including an unknown word kept verbatim.
38    pub fn as_str(&self) -> &str {
39        match self {
40            Self::User => "user",
41            Self::Default => "default",
42            Self::Policy => "policy",
43            Self::Unknown(word) => word,
44        }
45    }
46}
47
48impl Serialize for ReasoningEffortChangeSource {
49    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
50        serializer.serialize_str(self.as_str())
51    }
52}
53
54impl<'de> Deserialize<'de> for ReasoningEffortChangeSource {
55    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
56        let word = String::deserialize(deserializer)?;
57        Ok(match word.as_str() {
58            "user" => Self::User,
59            "default" => Self::Default,
60            "policy" => Self::Policy,
61            _ => Self::Unknown(word),
62        })
63    }
64}
65
66impl TodoStatus {
67    /// The exact wire spelling, including an unknown word kept verbatim.
68    pub fn as_str(&self) -> &str {
69        match self {
70            Self::Pending => "pending",
71            Self::InProgress => "inProgress",
72            Self::Completed => "completed",
73            Self::Cancelled => "cancelled",
74            Self::Unknown(word) => word,
75        }
76    }
77}
78
79impl Serialize for TodoStatus {
80    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
81        serializer.serialize_str(self.as_str())
82    }
83}
84
85impl<'de> Deserialize<'de> for TodoStatus {
86    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
87        let word = String::deserialize(deserializer)?;
88        Ok(match word.as_str() {
89            "pending" => Self::Pending,
90            "inProgress" => Self::InProgress,
91            "completed" => Self::Completed,
92            "cancelled" => Self::Cancelled,
93            _ => Self::Unknown(word),
94        })
95    }
96}
97
98impl Vcs {
99    /// The exact wire spelling, including an unknown word kept verbatim.
100    pub fn as_str(&self) -> &str {
101        match self {
102            Self::Git => "git",
103            Self::Sapling => "sapling",
104            Self::Unknown(word) => word,
105        }
106    }
107}
108
109impl Serialize for Vcs {
110    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
111        serializer.serialize_str(self.as_str())
112    }
113}
114
115impl<'de> Deserialize<'de> for Vcs {
116    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
117        let word = String::deserialize(deserializer)?;
118        Ok(match word.as_str() {
119            "git" => Self::Git,
120            "sapling" => Self::Sapling,
121            _ => Self::Unknown(word),
122        })
123    }
124}