1use crate::prelude::*;
2
3#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4#[repr(u8)]
5pub enum UriMatchType {
6 Domain = 0,
7 Host = 1,
8 StartsWith = 2,
9 Exact = 3,
10 RegularExpression = 4,
11 Never = 5,
12}
13
14impl serde::Serialize for UriMatchType {
15 fn serialize<S>(
16 &self,
17 serializer: S,
18 ) -> std::result::Result<S::Ok, S::Error>
19 where
20 S: serde::Serializer,
21 {
22 let v: u8 = match self {
23 Self::Domain => 0,
24 Self::Host => 1,
25 Self::StartsWith => 2,
26 Self::Exact => 3,
27 Self::RegularExpression => 4,
28 Self::Never => 5,
29 };
30 serializer.serialize_u8(v)
31 }
32}
33
34impl<'de> serde::Deserialize<'de> for UriMatchType {
35 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
36 where
37 D: serde::Deserializer<'de>,
38 {
39 let v = u8::deserialize(deserializer)?;
40 match v {
41 0 => Ok(Self::Domain),
42 1 => Ok(Self::Host),
43 2 => Ok(Self::StartsWith),
44 3 => Ok(Self::Exact),
45 4 => Ok(Self::RegularExpression),
46 5 => Ok(Self::Never),
47 _ => Err(serde::de::Error::custom(format!(
48 "invalid UriMatchType: {v}"
49 ))),
50 }
51 }
52}
53
54impl std::fmt::Display for UriMatchType {
55 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 #[allow(clippy::enum_glob_use)]
57 use UriMatchType::*;
58 let s = match self {
59 Domain => "domain",
60 Host => "host",
61 StartsWith => "starts_with",
62 Exact => "exact",
63 RegularExpression => "regular_expression",
64 Never => "never",
65 };
66 write!(f, "{s}")
67 }
68}
69
70#[derive(Debug, Copy, Clone, PartialEq, Eq)]
71pub enum TwoFactorProviderType {
72 Authenticator = 0,
73 Email = 1,
74 Duo = 2,
75 Yubikey = 3,
76 U2f = 4,
77 Remember = 5,
78 OrganizationDuo = 6,
79 WebAuthn = 7,
80}
81
82impl TwoFactorProviderType {
83 pub fn message(&self) -> &str {
84 match *self {
85 Self::Authenticator => "Enter the 6 digit verification code from your authenticator app.",
86 Self::Yubikey => "Insert your Yubikey and push the button.",
87 Self::Email => "Enter the PIN you received via email.",
88 _ => "Enter the code."
89 }
90 }
91
92 pub fn header(&self) -> &str {
93 match *self {
94 Self::Authenticator => "Authenticator App",
95 Self::Yubikey => "Yubikey",
96 Self::Email => "Email Code",
97 _ => "Two Factor Authentication",
98 }
99 }
100
101 pub fn grab(&self) -> bool {
102 !matches!(self, Self::Email)
103 }
104}
105
106impl<'de> serde::Deserialize<'de> for TwoFactorProviderType {
107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
108 where
109 D: serde::Deserializer<'de>,
110 {
111 struct TwoFactorProviderTypeVisitor;
112 impl serde::de::Visitor<'_> for TwoFactorProviderTypeVisitor {
113 type Value = TwoFactorProviderType;
114
115 fn expecting(
116 &self,
117 formatter: &mut std::fmt::Formatter,
118 ) -> std::fmt::Result {
119 formatter.write_str("two factor provider id")
120 }
121
122 fn visit_str<E>(
123 self,
124 value: &str,
125 ) -> std::result::Result<Self::Value, E>
126 where
127 E: serde::de::Error,
128 {
129 value.parse().map_err(serde::de::Error::custom)
130 }
131
132 fn visit_u64<E>(
133 self,
134 value: u64,
135 ) -> std::result::Result<Self::Value, E>
136 where
137 E: serde::de::Error,
138 {
139 std::convert::TryFrom::try_from(value)
140 .map_err(serde::de::Error::custom)
141 }
142 }
143
144 deserializer.deserialize_any(TwoFactorProviderTypeVisitor)
145 }
146}
147
148impl std::convert::TryFrom<u64> for TwoFactorProviderType {
149 type Error = Error;
150
151 fn try_from(ty: u64) -> Result<Self> {
152 match ty {
153 0 => Ok(Self::Authenticator),
154 1 => Ok(Self::Email),
155 2 => Ok(Self::Duo),
156 3 => Ok(Self::Yubikey),
157 4 => Ok(Self::U2f),
158 5 => Ok(Self::Remember),
159 6 => Ok(Self::OrganizationDuo),
160 7 => Ok(Self::WebAuthn),
161 _ => Err(Error::InvalidTwoFactorProvider {
162 ty: format!("{ty}"),
163 }),
164 }
165 }
166}
167
168impl std::str::FromStr for TwoFactorProviderType {
169 type Err = Error;
170
171 fn from_str(ty: &str) -> Result<Self> {
172 match ty {
173 "0" => Ok(Self::Authenticator),
174 "1" => Ok(Self::Email),
175 "2" => Ok(Self::Duo),
176 "3" => Ok(Self::Yubikey),
177 "4" => Ok(Self::U2f),
178 "5" => Ok(Self::Remember),
179 "6" => Ok(Self::OrganizationDuo),
180 "7" => Ok(Self::WebAuthn),
181 _ => Err(Error::InvalidTwoFactorProvider { ty: ty.to_string() }),
182 }
183 }
184}
185
186#[derive(Debug, Copy, Clone, PartialEq, Eq)]
187pub enum KdfType {
188 Pbkdf2 = 0,
189 Argon2id = 1,
190}
191
192impl<'de> serde::Deserialize<'de> for KdfType {
193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
194 where
195 D: serde::Deserializer<'de>,
196 {
197 struct KdfTypeVisitor;
198 impl serde::de::Visitor<'_> for KdfTypeVisitor {
199 type Value = KdfType;
200
201 fn expecting(
202 &self,
203 formatter: &mut std::fmt::Formatter,
204 ) -> std::fmt::Result {
205 formatter.write_str("kdf id")
206 }
207
208 fn visit_str<E>(
209 self,
210 value: &str,
211 ) -> std::result::Result<Self::Value, E>
212 where
213 E: serde::de::Error,
214 {
215 value.parse().map_err(serde::de::Error::custom)
216 }
217
218 fn visit_u64<E>(
219 self,
220 value: u64,
221 ) -> std::result::Result<Self::Value, E>
222 where
223 E: serde::de::Error,
224 {
225 std::convert::TryFrom::try_from(value)
226 .map_err(serde::de::Error::custom)
227 }
228 }
229
230 deserializer.deserialize_any(KdfTypeVisitor)
231 }
232}
233
234impl std::convert::TryFrom<u64> for KdfType {
235 type Error = Error;
236
237 fn try_from(ty: u64) -> Result<Self> {
238 match ty {
239 0 => Ok(Self::Pbkdf2),
240 1 => Ok(Self::Argon2id),
241 _ => Err(Error::InvalidKdfType {
242 ty: format!("{ty}"),
243 }),
244 }
245 }
246}
247
248impl std::str::FromStr for KdfType {
249 type Err = Error;
250
251 fn from_str(ty: &str) -> Result<Self> {
252 match ty {
253 "0" => Ok(Self::Pbkdf2),
254 "1" => Ok(Self::Argon2id),
255 _ => Err(Error::InvalidKdfType { ty: ty.to_string() }),
256 }
257 }
258}
259
260impl serde::Serialize for KdfType {
261 fn serialize<S>(
262 &self,
263 serializer: S,
264 ) -> std::result::Result<S::Ok, S::Error>
265 where
266 S: serde::Serializer,
267 {
268 let s = match self {
269 Self::Pbkdf2 => "0",
270 Self::Argon2id => "1",
271 };
272 serializer.serialize_str(s)
273 }
274}
275
276#[derive(Debug, Copy, Clone, PartialEq, Eq)]
277#[repr(u8)]
278pub enum CipherRepromptType {
279 None = 0,
280 Password = 1,
281}
282
283impl serde::Serialize for CipherRepromptType {
284 fn serialize<S>(
285 &self,
286 serializer: S,
287 ) -> std::result::Result<S::Ok, S::Error>
288 where
289 S: serde::Serializer,
290 {
291 let v: u8 = match self {
292 Self::None => 0,
293 Self::Password => 1,
294 };
295 serializer.serialize_u8(v)
296 }
297}
298
299impl<'de> serde::Deserialize<'de> for CipherRepromptType {
300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
301 where
302 D: serde::Deserializer<'de>,
303 {
304 let v = u8::deserialize(deserializer)?;
305 match v {
306 0 => Ok(Self::None),
307 1 => Ok(Self::Password),
308 _ => Err(serde::de::Error::custom(format!(
309 "invalid CipherRepromptType: {v}"
310 ))),
311 }
312 }
313}
314
315#[derive(Debug, Clone, Copy, PartialEq, Eq)]
316#[repr(u16)]
317pub enum FieldType {
318 Text = 0,
319 Hidden = 1,
320 Boolean = 2,
321 Linked = 3,
322}
323
324impl serde::Serialize for FieldType {
325 fn serialize<S>(
326 &self,
327 serializer: S,
328 ) -> std::result::Result<S::Ok, S::Error>
329 where
330 S: serde::Serializer,
331 {
332 let v: u16 = match self {
333 Self::Text => 0,
334 Self::Hidden => 1,
335 Self::Boolean => 2,
336 Self::Linked => 3,
337 };
338 serializer.serialize_u16(v)
339 }
340}
341
342impl<'de> serde::Deserialize<'de> for FieldType {
343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
344 where
345 D: serde::Deserializer<'de>,
346 {
347 let v = u16::deserialize(deserializer)?;
348 match v {
349 0 => Ok(Self::Text),
350 1 => Ok(Self::Hidden),
351 2 => Ok(Self::Boolean),
352 3 => Ok(Self::Linked),
353 _ => Err(serde::de::Error::custom(format!(
354 "invalid FieldType: {v}"
355 ))),
356 }
357 }
358}
359
360#[derive(Debug, Clone, Copy, PartialEq, Eq)]
361#[repr(u16)]
362pub enum LinkedIdType {
363 LoginUsername = 100,
364 LoginPassword = 101,
365 CardCardholderName = 300,
366 CardExpMonth = 301,
367 CardExpYear = 302,
368 CardCode = 303,
369 CardBrand = 304,
370 CardNumber = 305,
371 IdentityTitle = 400,
372 IdentityMiddleName = 401,
373 IdentityAddress1 = 402,
374 IdentityAddress2 = 403,
375 IdentityAddress3 = 404,
376 IdentityCity = 405,
377 IdentityState = 406,
378 IdentityPostalCode = 407,
379 IdentityCountry = 408,
380 IdentityCompany = 409,
381 IdentityEmail = 410,
382 IdentityPhone = 411,
383 IdentitySsn = 412,
384 IdentityUsername = 413,
385 IdentityPassportNumber = 414,
386 IdentityLicenseNumber = 415,
387 IdentityFirstName = 416,
388 IdentityLastName = 417,
389 IdentityFullName = 418,
390}
391
392impl serde::Serialize for LinkedIdType {
393 fn serialize<S>(
394 &self,
395 serializer: S,
396 ) -> std::result::Result<S::Ok, S::Error>
397 where
398 S: serde::Serializer,
399 {
400 let v: u16 = match self {
401 Self::LoginUsername => 100,
402 Self::LoginPassword => 101,
403 Self::CardCardholderName => 300,
404 Self::CardExpMonth => 301,
405 Self::CardExpYear => 302,
406 Self::CardCode => 303,
407 Self::CardBrand => 304,
408 Self::CardNumber => 305,
409 Self::IdentityTitle => 400,
410 Self::IdentityMiddleName => 401,
411 Self::IdentityAddress1 => 402,
412 Self::IdentityAddress2 => 403,
413 Self::IdentityAddress3 => 404,
414 Self::IdentityCity => 405,
415 Self::IdentityState => 406,
416 Self::IdentityPostalCode => 407,
417 Self::IdentityCountry => 408,
418 Self::IdentityCompany => 409,
419 Self::IdentityEmail => 410,
420 Self::IdentityPhone => 411,
421 Self::IdentitySsn => 412,
422 Self::IdentityUsername => 413,
423 Self::IdentityPassportNumber => 414,
424 Self::IdentityLicenseNumber => 415,
425 Self::IdentityFirstName => 416,
426 Self::IdentityLastName => 417,
427 Self::IdentityFullName => 418,
428 };
429 serializer.serialize_u16(v)
430 }
431}
432
433impl<'de> serde::Deserialize<'de> for LinkedIdType {
434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
435 where
436 D: serde::Deserializer<'de>,
437 {
438 let v = u16::deserialize(deserializer)?;
439 match v {
440 100 => Ok(Self::LoginUsername),
441 101 => Ok(Self::LoginPassword),
442 300 => Ok(Self::CardCardholderName),
443 301 => Ok(Self::CardExpMonth),
444 302 => Ok(Self::CardExpYear),
445 303 => Ok(Self::CardCode),
446 304 => Ok(Self::CardBrand),
447 305 => Ok(Self::CardNumber),
448 400 => Ok(Self::IdentityTitle),
449 401 => Ok(Self::IdentityMiddleName),
450 402 => Ok(Self::IdentityAddress1),
451 403 => Ok(Self::IdentityAddress2),
452 404 => Ok(Self::IdentityAddress3),
453 405 => Ok(Self::IdentityCity),
454 406 => Ok(Self::IdentityState),
455 407 => Ok(Self::IdentityPostalCode),
456 408 => Ok(Self::IdentityCountry),
457 409 => Ok(Self::IdentityCompany),
458 410 => Ok(Self::IdentityEmail),
459 411 => Ok(Self::IdentityPhone),
460 412 => Ok(Self::IdentitySsn),
461 413 => Ok(Self::IdentityUsername),
462 414 => Ok(Self::IdentityPassportNumber),
463 415 => Ok(Self::IdentityLicenseNumber),
464 416 => Ok(Self::IdentityFirstName),
465 417 => Ok(Self::IdentityLastName),
466 418 => Ok(Self::IdentityFullName),
467 _ => Err(serde::de::Error::custom(format!(
468 "invalid LinkedIdType: {v}"
469 ))),
470 }
471 }
472}