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