muse_code_sdk/msp/view/
approval_wire_words.rs1use 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 #[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 #[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 #[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 #[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 #[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 #[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}