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