Skip to main content

muse_code_sdk/msp/view/
approval_wire_words.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use super::approval::ApprovalAmendmentDurability;
4use super::approval::ApprovalChoiceScope;
5use super::approval::ApprovalDecision;
6use super::approval::ApprovalPersistenceStatus;
7use super::approval::ApprovalPolicyResult;
8use super::approval::ApprovalResolvedBy;
9use serde::Deserialize;
10use serde::Deserializer;
11use serde::Serialize;
12use serde::Serializer;
13
14impl ApprovalDecision {
15    /// The exact wire spelling, including a value from a newer host.
16    #[must_use]
17    pub fn as_str(&self) -> &str {
18        match self {
19            Self::Approved => "approved",
20            Self::ApprovedForSession => "approvedForSession",
21            Self::ApprovedPolicyAmendment => "approvedPolicyAmendment",
22            Self::Denied => "denied",
23            Self::DeniedPolicyAmendment => "deniedPolicyAmendment",
24            Self::TimedOut => "timedOut",
25            Self::Abort => "abort",
26            Self::Unknown(value) => value,
27        }
28    }
29}
30
31impl Serialize for ApprovalDecision {
32    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
33    where
34        S: Serializer,
35    {
36        serializer.serialize_str(self.as_str())
37    }
38}
39
40impl<'de> Deserialize<'de> for ApprovalDecision {
41    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
42    where
43        D: Deserializer<'de>,
44    {
45        let value = String::deserialize(deserializer)?;
46        Ok(match value.as_str() {
47            "approved" => Self::Approved,
48            "approvedForSession" => Self::ApprovedForSession,
49            "approvedPolicyAmendment" => Self::ApprovedPolicyAmendment,
50            "denied" => Self::Denied,
51            "deniedPolicyAmendment" => Self::DeniedPolicyAmendment,
52            "timedOut" => Self::TimedOut,
53            "abort" => Self::Abort,
54            _ => Self::Unknown(value),
55        })
56    }
57}
58
59impl ApprovalChoiceScope {
60    /// The exact wire spelling, including a value from a newer host.
61    #[must_use]
62    pub fn as_str(&self) -> &str {
63        match self {
64            Self::Once => "once",
65            Self::Session => "session",
66            Self::LocalPersistent => "localPersistent",
67            Self::Unknown(value) => value,
68        }
69    }
70}
71
72impl Serialize for ApprovalChoiceScope {
73    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
74    where
75        S: Serializer,
76    {
77        serializer.serialize_str(self.as_str())
78    }
79}
80
81impl<'de> Deserialize<'de> for ApprovalChoiceScope {
82    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
83    where
84        D: Deserializer<'de>,
85    {
86        let value = String::deserialize(deserializer)?;
87        Ok(match value.as_str() {
88            "once" => Self::Once,
89            "session" => Self::Session,
90            "localPersistent" => Self::LocalPersistent,
91            _ => Self::Unknown(value),
92        })
93    }
94}
95
96impl ApprovalPersistenceStatus {
97    /// The exact wire spelling, including a value from a newer host.
98    #[must_use]
99    pub fn as_str(&self) -> &str {
100        match self {
101            Self::Succeeded => "succeeded",
102            Self::Failed => "failed",
103            Self::Unknown(value) => value,
104        }
105    }
106}
107
108impl Serialize for ApprovalPersistenceStatus {
109    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
110    where
111        S: Serializer,
112    {
113        serializer.serialize_str(self.as_str())
114    }
115}
116
117impl<'de> Deserialize<'de> for ApprovalPersistenceStatus {
118    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
119    where
120        D: Deserializer<'de>,
121    {
122        let value = String::deserialize(deserializer)?;
123        Ok(match value.as_str() {
124            "succeeded" => Self::Succeeded,
125            "failed" => Self::Failed,
126            _ => Self::Unknown(value),
127        })
128    }
129}
130
131impl ApprovalPolicyResult {
132    /// The exact wire spelling, including a value from a newer host.
133    #[must_use]
134    pub fn as_str(&self) -> &str {
135        match self {
136            Self::Allow => "allow",
137            Self::Deny => "deny",
138            Self::Unknown(value) => value,
139        }
140    }
141}
142
143impl Serialize for ApprovalPolicyResult {
144    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
145    where
146        S: Serializer,
147    {
148        serializer.serialize_str(self.as_str())
149    }
150}
151
152impl<'de> Deserialize<'de> for ApprovalPolicyResult {
153    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
154    where
155        D: Deserializer<'de>,
156    {
157        let value = String::deserialize(deserializer)?;
158        Ok(match value.as_str() {
159            "allow" => Self::Allow,
160            "deny" => Self::Deny,
161            _ => Self::Unknown(value),
162        })
163    }
164}
165
166impl ApprovalAmendmentDurability {
167    /// The exact wire spelling, including a value from a newer host.
168    #[must_use]
169    pub fn as_str(&self) -> &str {
170        match self {
171            Self::Session => "session",
172            Self::LocalPersistent => "localPersistent",
173            Self::Unknown(value) => value,
174        }
175    }
176}
177
178impl Serialize for ApprovalAmendmentDurability {
179    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
180    where
181        S: Serializer,
182    {
183        serializer.serialize_str(self.as_str())
184    }
185}
186
187impl<'de> Deserialize<'de> for ApprovalAmendmentDurability {
188    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
189    where
190        D: Deserializer<'de>,
191    {
192        let value = String::deserialize(deserializer)?;
193        Ok(match value.as_str() {
194            "session" => Self::Session,
195            "localPersistent" => Self::LocalPersistent,
196            _ => Self::Unknown(value),
197        })
198    }
199}
200
201impl ApprovalResolvedBy {
202    /// The exact wire spelling, including a value from a newer host.
203    #[must_use]
204    pub fn as_str(&self) -> &str {
205        match self {
206            Self::User => "user",
207            Self::Policy => "policy",
208            Self::LlmJudge => "llmJudge",
209            Self::Unknown(value) => value,
210        }
211    }
212}
213
214impl Serialize for ApprovalResolvedBy {
215    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
216    where
217        S: Serializer,
218    {
219        serializer.serialize_str(self.as_str())
220    }
221}
222
223impl<'de> Deserialize<'de> for ApprovalResolvedBy {
224    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
225    where
226        D: Deserializer<'de>,
227    {
228        let value = String::deserialize(deserializer)?;
229        Ok(match value.as_str() {
230            "user" => Self::User,
231            "policy" => Self::Policy,
232            "llmJudge" => Self::LlmJudge,
233            _ => Self::Unknown(value),
234        })
235    }
236}