1use serde::{Deserialize, Serialize};
2use std::fmt;
3use std::str::FromStr;
4
5use crate::errors::ParseEnumError;
6
7#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
8#[serde(rename_all = "lowercase")]
9pub enum JwtAudience {
10 Web,
11 Api,
12 A2a,
13 Mcp,
14 Internal,
15 Bridge,
16 Hook,
17 #[serde(untagged)]
18 Resource(String),
19}
20
21impl JwtAudience {
22 pub fn as_str(&self) -> &str {
23 match self {
24 Self::Web => "web",
25 Self::Api => "api",
26 Self::A2a => "a2a",
27 Self::Mcp => "mcp",
28 Self::Internal => "internal",
29 Self::Bridge => "bridge",
30 Self::Hook => "hook",
31 Self::Resource(s) => s.as_str(),
32 }
33 }
34
35 pub fn standard() -> Vec<Self> {
36 vec![Self::Web, Self::Api, Self::A2a, Self::Mcp]
37 }
38
39 pub fn service() -> Vec<Self> {
40 vec![Self::Api, Self::Mcp, Self::A2a, Self::Internal]
41 }
42}
43
44impl fmt::Display for JwtAudience {
45 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
46 write!(f, "{}", self.as_str())
47 }
48}
49
50impl FromStr for JwtAudience {
51 type Err = ParseEnumError;
52 fn from_str(s: &str) -> Result<Self, Self::Err> {
53 match s {
54 "web" => Ok(Self::Web),
55 "api" => Ok(Self::Api),
56 "a2a" => Ok(Self::A2a),
57 "mcp" => Ok(Self::Mcp),
58 "internal" => Ok(Self::Internal),
59 "bridge" => Ok(Self::Bridge),
60 "hook" => Ok(Self::Hook),
61 _ => Ok(Self::Resource(s.to_string())),
62 }
63 }
64}
65
66#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
67#[serde(rename_all = "lowercase")]
68pub enum UserType {
69 Admin,
70 User,
71 A2a,
72 Mcp,
73 Service,
74 Anon,
75 Unknown,
76}
77
78impl UserType {
79 pub const fn as_str(&self) -> &'static str {
80 match self {
81 Self::Admin => "admin",
82 Self::User => "user",
83 Self::A2a => "a2a",
84 Self::Mcp => "mcp",
85 Self::Service => "service",
86 Self::Anon => "anon",
87 Self::Unknown => "unknown",
88 }
89 }
90
91 pub const fn rate_tier(&self) -> RateLimitTier {
92 match self {
93 Self::Admin => RateLimitTier::Admin,
94 Self::User => RateLimitTier::User,
95 Self::A2a => RateLimitTier::A2a,
96 Self::Mcp => RateLimitTier::Mcp,
97 Self::Service => RateLimitTier::Service,
98 Self::Anon | Self::Unknown => RateLimitTier::Anon,
99 }
100 }
101}
102
103impl fmt::Display for UserType {
104 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
105 write!(f, "{}", self.as_str())
106 }
107}
108
109impl FromStr for UserType {
110 type Err = ParseEnumError;
111 fn from_str(s: &str) -> Result<Self, Self::Err> {
112 match s {
113 "admin" => Ok(Self::Admin),
114 "user" => Ok(Self::User),
115 "a2a" => Ok(Self::A2a),
116 "mcp" => Ok(Self::Mcp),
117 "service" => Ok(Self::Service),
118 "anon" => Ok(Self::Anon),
119 "unknown" => Ok(Self::Unknown),
120 _ => Err(ParseEnumError::new("user_type", s)),
121 }
122 }
123}
124
125#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
126pub enum TokenType {
127 #[default]
128 Bearer,
129}
130
131impl TokenType {
132 pub const fn as_str(self) -> &'static str {
133 match self {
134 Self::Bearer => "Bearer",
135 }
136 }
137}
138
139impl fmt::Display for TokenType {
140 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
141 write!(f, "Bearer")
142 }
143}
144
145#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
146#[serde(rename_all = "lowercase")]
147pub enum RateLimitTier {
148 Admin,
149 User,
150 A2a,
151 Mcp,
152 Service,
153 Anon,
154}
155
156impl RateLimitTier {
157 pub const fn as_str(&self) -> &'static str {
158 match self {
159 Self::Admin => "admin",
160 Self::User => "user",
161 Self::A2a => "a2a",
162 Self::Mcp => "mcp",
163 Self::Service => "service",
164 Self::Anon => "anon",
165 }
166 }
167}
168
169impl fmt::Display for RateLimitTier {
170 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
171 write!(f, "{}", self.as_str())
172 }
173}
174
175impl FromStr for RateLimitTier {
176 type Err = ParseEnumError;
177 fn from_str(s: &str) -> Result<Self, Self::Err> {
178 match s {
179 "admin" => Ok(Self::Admin),
180 "user" => Ok(Self::User),
181 "a2a" => Ok(Self::A2a),
182 "mcp" => Ok(Self::Mcp),
183 "service" => Ok(Self::Service),
184 "anon" => Ok(Self::Anon),
185 _ => Err(ParseEnumError::new("rate_limit_tier", s)),
186 }
187 }
188}
189
190#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
191#[serde(rename_all = "lowercase")]
192pub enum UserRole {
193 Admin,
194 User,
195 Anonymous,
196}
197
198impl UserRole {
199 pub const fn as_str(&self) -> &'static str {
200 match self {
201 Self::Admin => "admin",
202 Self::User => "user",
203 Self::Anonymous => "anonymous",
204 }
205 }
206}
207
208impl fmt::Display for UserRole {
209 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
210 write!(f, "{}", self.as_str())
211 }
212}
213
214impl FromStr for UserRole {
215 type Err = ParseEnumError;
216 fn from_str(s: &str) -> Result<Self, Self::Err> {
217 match s {
218 "admin" => Ok(Self::Admin),
219 "user" => Ok(Self::User),
220 "anonymous" => Ok(Self::Anonymous),
221 _ => Err(ParseEnumError::new("user_role", s)),
222 }
223 }
224}
225
226#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
227#[serde(rename_all = "lowercase")]
228pub enum UserStatus {
229 Active,
230 Inactive,
231 Suspended,
232 Pending,
233 Deleted,
234 Temporary,
235}
236
237impl UserStatus {
238 pub const fn as_str(&self) -> &'static str {
239 match self {
240 Self::Active => "active",
241 Self::Inactive => "inactive",
242 Self::Suspended => "suspended",
243 Self::Pending => "pending",
244 Self::Deleted => "deleted",
245 Self::Temporary => "temporary",
246 }
247 }
248
249 pub const fn is_active(&self) -> bool {
250 matches!(self, Self::Active)
251 }
252}
253
254impl fmt::Display for UserStatus {
255 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
256 write!(f, "{}", self.as_str())
257 }
258}
259
260impl FromStr for UserStatus {
261 type Err = ParseEnumError;
262 fn from_str(s: &str) -> Result<Self, Self::Err> {
263 match s {
264 "active" => Ok(Self::Active),
265 "inactive" => Ok(Self::Inactive),
266 "suspended" => Ok(Self::Suspended),
267 "pending" => Ok(Self::Pending),
268 "deleted" => Ok(Self::Deleted),
269 "temporary" => Ok(Self::Temporary),
270 _ => Err(ParseEnumError::new("user_status", s)),
271 }
272 }
273}