Skip to main content

muse_code_sdk/msp/view/
state_wire_words.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use super::state::ApprovalModeSource;
4use super::state::PermissionApprovalAxis;
5use super::state::PermissionFilesystemAxis;
6use super::state::PermissionNetworkAxis;
7use super::state::ReviewerAuthority;
8use serde::Deserialize;
9use serde::Deserializer;
10use serde::Serialize;
11use serde::Serializer;
12
13impl ReviewerAuthority {
14    /// The exact wire spelling, including a value from a newer host.
15    #[must_use]
16    pub fn as_str(&self) -> &str {
17        match self {
18            Self::AutoReview => "autoReview",
19            Self::Human => "human",
20            Self::None => "none",
21            Self::Unknown(value) => value,
22        }
23    }
24}
25
26impl Serialize for ReviewerAuthority {
27    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
28    where
29        S: Serializer,
30    {
31        serializer.serialize_str(self.as_str())
32    }
33}
34
35impl<'de> Deserialize<'de> for ReviewerAuthority {
36    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
37    where
38        D: Deserializer<'de>,
39    {
40        let value = String::deserialize(deserializer)?;
41        Ok(match value.as_str() {
42            "autoReview" => Self::AutoReview,
43            "human" => Self::Human,
44            "none" => Self::None,
45            _ => Self::Unknown(value),
46        })
47    }
48}
49
50impl ApprovalModeSource {
51    /// The exact wire spelling, including a value from a newer host.
52    #[must_use]
53    pub fn as_str(&self) -> &str {
54        match self {
55            Self::Startup => "startup",
56            Self::Replay => "replay",
57            Self::ApprovalReconfigure => "approvalReconfigure",
58            Self::Unknown(value) => value,
59        }
60    }
61}
62
63impl Serialize for ApprovalModeSource {
64    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
65    where
66        S: Serializer,
67    {
68        serializer.serialize_str(self.as_str())
69    }
70}
71
72impl<'de> Deserialize<'de> for ApprovalModeSource {
73    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
74    where
75        D: Deserializer<'de>,
76    {
77        let value = String::deserialize(deserializer)?;
78        Ok(match value.as_str() {
79            "startup" => Self::Startup,
80            "replay" => Self::Replay,
81            "approvalReconfigure" => Self::ApprovalReconfigure,
82            _ => Self::Unknown(value),
83        })
84    }
85}
86
87impl PermissionFilesystemAxis {
88    /// The exact wire spelling, including a value from a newer host.
89    #[must_use]
90    pub fn as_str(&self) -> &str {
91        match self {
92            Self::Sandboxed => "sandboxed",
93            Self::Unrestricted => "unrestricted",
94            Self::Unknown(value) => value,
95        }
96    }
97}
98
99impl Serialize for PermissionFilesystemAxis {
100    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
101    where
102        S: Serializer,
103    {
104        serializer.serialize_str(self.as_str())
105    }
106}
107
108impl<'de> Deserialize<'de> for PermissionFilesystemAxis {
109    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
110    where
111        D: Deserializer<'de>,
112    {
113        let value = String::deserialize(deserializer)?;
114        Ok(match value.as_str() {
115            "sandboxed" => Self::Sandboxed,
116            "unrestricted" => Self::Unrestricted,
117            _ => Self::Unknown(value),
118        })
119    }
120}
121
122impl PermissionNetworkAxis {
123    /// The exact wire spelling, including a value from a newer host.
124    #[must_use]
125    pub fn as_str(&self) -> &str {
126        match self {
127            Self::Restricted => "restricted",
128            Self::ProxyOnly => "off",
129            Self::Enabled => "enabled",
130            Self::Unknown(value) => value,
131        }
132    }
133}
134
135impl Serialize for PermissionNetworkAxis {
136    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
137    where
138        S: Serializer,
139    {
140        serializer.serialize_str(self.as_str())
141    }
142}
143
144impl<'de> Deserialize<'de> for PermissionNetworkAxis {
145    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
146    where
147        D: Deserializer<'de>,
148    {
149        let value = String::deserialize(deserializer)?;
150        Ok(match value.as_str() {
151            "restricted" => Self::Restricted,
152            "off" => Self::ProxyOnly,
153            "enabled" => Self::Enabled,
154            _ => Self::Unknown(value),
155        })
156    }
157}
158
159impl PermissionApprovalAxis {
160    /// The exact wire spelling, including a value from a newer host.
161    #[must_use]
162    pub fn as_str(&self) -> &str {
163        match self {
164            Self::OnRequest => "onRequest",
165            Self::PromptUnmatched => "promptUnmatched",
166            Self::AllowAll => "allowAll",
167            Self::Unknown(value) => value,
168        }
169    }
170}
171
172impl Serialize for PermissionApprovalAxis {
173    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
174    where
175        S: Serializer,
176    {
177        serializer.serialize_str(self.as_str())
178    }
179}
180
181impl<'de> Deserialize<'de> for PermissionApprovalAxis {
182    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
183    where
184        D: Deserializer<'de>,
185    {
186        let value = String::deserialize(deserializer)?;
187        Ok(match value.as_str() {
188            "onRequest" => Self::OnRequest,
189            "promptUnmatched" => Self::PromptUnmatched,
190            "allowAll" => Self::AllowAll,
191            _ => Self::Unknown(value),
192        })
193    }
194}