Skip to main content

structured_webauthn/response/
ser.rs

1extern crate alloc;
2use super::{
3    AllAcceptedCredentialsOptions, AuthTransports, AuthenticatorAttachment, AuthenticatorTransport,
4    Challenge, CredentialId, CurrentUserDetailsOptions, Origin, SentChallenge,
5};
6use alloc::borrow::Cow;
7use core::{
8    fmt::{self, Formatter},
9    marker::PhantomData,
10};
11use serde::{
12    de::{Deserialize, Deserializer, Error, IgnoredAny, MapAccess, SeqAccess, Unexpected, Visitor},
13    ser::{Serialize, SerializeSeq as _, SerializeStruct as _, Serializer},
14};
15/// [`"ble"`](https://www.w3.org/TR/webauthn-3/#dom-authenticatortransport-ble).
16const BLE: &str = "ble";
17/// [`"hybrid"`](https://www.w3.org/TR/webauthn-3/#dom-authenticatortransport-hybrid).
18const HYBRID: &str = "hybrid";
19/// [`"internal"`](https://www.w3.org/TR/webauthn-3/#dom-authenticatortransport-internal).
20const INTERNAL: &str = "internal";
21/// [`"nfc"`](https://www.w3.org/TR/webauthn-3/#dom-authenticatortransport-nfc).
22const NFC: &str = "nfc";
23/// [`"smart-card"`](https://www.w3.org/TR/webauthn-3/#dom-authenticatortransport-smart-card).
24const SMART_CARD: &str = "smart-card";
25/// [`"usb"`](https://www.w3.org/TR/webauthn-3/#dom-authenticatortransport-usb).
26const USB: &str = "usb";
27impl Serialize for AuthenticatorTransport {
28    /// Serializes `self` as
29    /// [`AuthenticatorTransport`](https://www.w3.org/TR/webauthn-3/#enumdef-authenticatortransport).
30    ///
31    /// # Examples
32    ///
33    /// ```
34    /// # use structured_webauthn::response::AuthenticatorTransport;
35    /// assert_eq!(
36    ///     serde_json::to_string(&AuthenticatorTransport::Usb)?,
37    ///     r#""usb""#
38    /// );
39    /// # Ok::<_, serde_json::Error>(())
40    /// ```
41    #[inline]
42    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
43    where
44        S: Serializer,
45    {
46        serializer.serialize_str(match *self {
47            Self::Ble => BLE,
48            Self::Hybrid => HYBRID,
49            Self::Internal => INTERNAL,
50            Self::Nfc => NFC,
51            Self::SmartCard => SMART_CARD,
52            Self::Usb => USB,
53        })
54    }
55}
56impl<'de> Deserialize<'de> for AuthenticatorTransport {
57    /// Deserializes [`prim@str`] based on
58    /// [`AuthenticatorTransport`](https://www.w3.org/TR/webauthn-3/#enumdef-authenticatortransport).
59    ///
60    /// Note `"cable"` is also supported and will be interpreted as [`Self::Hybrid`].
61    ///
62    /// # Examples
63    ///
64    /// ```
65    /// # use structured_webauthn::response::AuthenticatorTransport;
66    /// assert!(matches!(
67    ///     serde_json::from_str::<AuthenticatorTransport>(r#""usb""#)?,
68    ///     AuthenticatorTransport::Usb
69    /// ));
70    /// // Case matters.
71    /// assert!(serde_json::from_str::<AuthenticatorTransport>(r#""Usb""#).is_err());
72    /// # Ok::<_, serde_json::Error>(())
73    /// ```
74    #[inline]
75    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
76    where
77        D: Deserializer<'de>,
78    {
79        /// `Visitor` for `AuthenticatorTransport`.
80        struct AuthenticatorTransportVisitor;
81        impl Visitor<'_> for AuthenticatorTransportVisitor {
82            type Value = AuthenticatorTransport;
83            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
84                formatter.write_str("AuthenticatorTransport")
85            }
86            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
87            where
88                E: Error,
89            {
90                /// Legacy version of [`Self::Hybrid`].
91                const CA_BLE: &str = "cable";
92                match v {
93                    BLE => Ok(AuthenticatorTransport::Ble),
94                    CA_BLE | HYBRID => Ok(AuthenticatorTransport::Hybrid),
95                    INTERNAL => Ok(AuthenticatorTransport::Internal),
96                    NFC => Ok(AuthenticatorTransport::Nfc),
97                    SMART_CARD => Ok(AuthenticatorTransport::SmartCard),
98                    USB => Ok(AuthenticatorTransport::Usb),
99                    _ => Err(E::invalid_value(
100                        Unexpected::Str(v),
101                        &format!(
102                            "'{BLE}', '{CA_BLE}', '{HYBRID}', '{INTERNAL}', '{NFC}', '{SMART_CARD}', or '{USB}'"
103                        )
104                        .as_str(),
105                    )),
106                }
107            }
108        }
109        deserializer.deserialize_str(AuthenticatorTransportVisitor)
110    }
111}
112impl Serialize for AuthTransports {
113    /// Serializes `self` based on
114    /// [`transports`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialdescriptor-transports).
115    ///
116    /// # Examples
117    ///
118    /// ```
119    /// # use structured_webauthn::response::{AuthTransports, AuthenticatorTransport};
120    /// # #[cfg(feature = "custom")]
121    /// assert_eq!(
122    ///     serde_json::to_string(&AuthTransports::ALL)?,
123    ///     r#"["ble","hybrid","internal","nfc","smart-card","usb"]"#
124    /// );
125    /// # Ok::<_, serde_json::Error>(())
126    /// ```
127    #[expect(clippy::unreachable, reason = "there is a bug, so we want to crash")]
128    #[inline]
129    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
130    where
131        S: Serializer,
132    {
133        let count = usize::try_from(self.count())
134            .unwrap_or_else(|_e| unreachable!("there is a bug in AuthenticatorTransports::count"));
135        serializer.serialize_seq(Some(count)).and_then(|mut ser| {
136            if self.contains(AuthenticatorTransport::Ble) {
137                ser.serialize_element(&AuthenticatorTransport::Ble)
138            } else {
139                Ok(())
140            }
141            .and_then(|()| {
142                if self.contains(AuthenticatorTransport::Hybrid) {
143                    ser.serialize_element(&AuthenticatorTransport::Hybrid)
144                } else {
145                    Ok(())
146                }
147                .and_then(|()| {
148                    if self.contains(AuthenticatorTransport::Internal) {
149                        ser.serialize_element(&AuthenticatorTransport::Internal)
150                    } else {
151                        Ok(())
152                    }
153                    .and_then(|()| {
154                        if self.contains(AuthenticatorTransport::Nfc) {
155                            ser.serialize_element(&AuthenticatorTransport::Nfc)
156                        } else {
157                            Ok(())
158                        }
159                        .and_then(|()| {
160                            if self.contains(AuthenticatorTransport::SmartCard) {
161                                ser.serialize_element(&AuthenticatorTransport::SmartCard)
162                            } else {
163                                Ok(())
164                            }
165                            .and_then(|()| {
166                                if self.contains(AuthenticatorTransport::Usb) {
167                                    ser.serialize_element(&AuthenticatorTransport::Usb)
168                                } else {
169                                    Ok(())
170                                }
171                                .and_then(|()| ser.end())
172                            })
173                        })
174                    })
175                })
176            })
177        })
178    }
179}
180impl<'de> Deserialize<'de> for AuthTransports {
181    /// Deserializes a sequence based on
182    /// [`transports`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialdescriptor-transports).
183    ///
184    /// # Examples
185    ///
186    /// ```
187    /// # use structured_webauthn::response::{AuthTransports, AuthenticatorTransport};
188    /// # #[cfg(feature = "custom")]
189    /// assert_eq!(
190    ///     serde_json::from_str::<AuthTransports>(
191    ///         r#"["ble","hybrid","internal","nfc","smart-card","usb"]"#
192    ///     )
193    ///     ?.count(),
194    ///     6
195    /// );
196    /// // Errors since `"foo"` is not valid.
197    /// assert!(serde_json::from_str::<AuthTransports>(r#"["foo"]"#).is_err());
198    /// # Ok::<_, serde_json::Error>(())
199    /// ```
200    #[inline]
201    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
202    where
203        D: Deserializer<'de>,
204    {
205        /// `Visitor` for `AuthTransports`.
206        struct AuthTransportsVisitor;
207        impl<'d> Visitor<'d> for AuthTransportsVisitor {
208            type Value = AuthTransports;
209            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
210                formatter.write_str("AuthTransports")
211            }
212            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
213            where
214                A: SeqAccess<'d>,
215            {
216                let mut transports = AuthTransports::new();
217                while let Some(val) = seq.next_element::<AuthenticatorTransport>()? {
218                    transports = transports.add_transport(val);
219                }
220                Ok(transports)
221            }
222        }
223        deserializer.deserialize_seq(AuthTransportsVisitor)
224    }
225}
226impl<T: AsRef<[u8]>> Serialize for CredentialId<T> {
227    /// Serializes `self` into a [`prim@str`] based on
228    /// [`id`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialdescriptorjson-id).
229    ///
230    /// # Examples
231    ///
232    /// ```
233    /// # use structured_webauthn::response::CredentialId;
234    /// // `CredentialId::try_from` only exists when `custom` is enabled; and even then, it is
235    /// // likely never needed since the `CredentialId` was originally sent from the client and is likely
236    /// // stored in a database which would be fetched by `UserHandle` or `Authentication::raw_id`.
237    /// # #[cfg(feature = "custom")]
238    /// assert_eq!(
239    ///     serde_json::to_string(&CredentialId::try_from(vec![0; 16].into_boxed_slice())?).unwrap(),
240    ///     r#""AAAAAAAAAAAAAAAAAAAAAA""#
241    /// );
242    /// # Ok::<_, structured_webauthn::AggErr>(())
243    ///```
244    #[inline]
245    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
246    where
247        S: Serializer,
248    {
249        serializer.serialize_str(base64url_nopad::encode(self.0.as_ref()).as_str())
250    }
251}
252impl<'de> Deserialize<'de> for CredentialId<Box<[u8]>> {
253    /// Deserializes [`prim@str`] based on
254    /// [`id`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialdescriptorjson-id).
255    ///
256    /// # Examples
257    ///
258    /// ```
259    /// # use structured_webauthn::response::CredentialId;
260    /// # #[cfg(feature = "custom")]
261    /// assert_eq!(
262    ///     serde_json::from_str::<CredentialId<_>>(r#""AAAAAAAAAAAAAAAAAAAAAA""#).unwrap(),
263    ///     CredentialId::try_from(vec![0; 16].into_boxed_slice())?
264    /// );
265    /// # Ok::<_, structured_webauthn::AggErr>(())
266    ///```
267    #[inline]
268    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
269    where
270        D: Deserializer<'de>,
271    {
272        /// `Visitor` for `CredentialId`.
273        struct CredentialIdVisitor;
274        impl Visitor<'_> for CredentialIdVisitor {
275            type Value = CredentialId<Box<[u8]>>;
276            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
277                formatter.write_str("CredentialId")
278            }
279            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
280            where
281                E: Error,
282            {
283                /// Minimum possible encoded length of a `CredentialId`.
284                const MIN_LEN: usize = base64url_nopad::encode_len(super::CRED_ID_MIN_LEN);
285                /// Maximum possible encoded length of a `CredentialId`.
286                const MAX_LEN: usize = base64url_nopad::encode_len(super::CRED_ID_MAX_LEN);
287                if (MIN_LEN..=MAX_LEN).contains(&v.len()) {
288                    base64url_nopad::decode(v.as_bytes())
289                        .map_err(E::custom)
290                        .map(|c| CredentialId(c.into_boxed_slice()))
291                } else {
292                    Err(E::invalid_value(
293                        Unexpected::Str(v),
294                        &"16 to 1023 bytes encoded in base64url without padding",
295                    ))
296                }
297            }
298        }
299        deserializer.deserialize_str(CredentialIdVisitor)
300    }
301}
302impl<'de> Deserialize<'de> for AuthenticatorAttachment {
303    /// Deserializes [`prim@str`] based on
304    /// [`AuthenticatorAttachment`](https://www.w3.org/TR/webauthn-3/#enumdef-authenticatorattachment).
305    ///
306    /// # Examples
307    ///
308    /// ```
309    /// # use structured_webauthn::response::AuthenticatorAttachment;
310    /// assert!(matches!(
311    ///     serde_json::from_str::<AuthenticatorAttachment>(r#""cross-platform""#)?,
312    ///     AuthenticatorAttachment::CrossPlatform)
313    /// );
314    /// assert!(matches!(
315    ///     serde_json::from_str::<AuthenticatorAttachment>(r#""platform""#)?,
316    ///     AuthenticatorAttachment::Platform)
317    /// );
318    /// // Case matters.
319    /// assert!(serde_json::from_str::<AuthenticatorAttachment>(r#""Platform""#).is_err());
320    /// // `AuthenticatorAttachment::None` is not deserializable.
321    /// assert!(serde_json::from_str::<AuthenticatorAttachment>(r#""""#).is_err());
322    /// assert!(serde_json::from_str::<AuthenticatorAttachment>("null").is_err());
323    /// assert!(serde_json::from_str::<AuthenticatorAttachment>(r#""none""#).is_err());
324    /// assert!(serde_json::from_str::<AuthenticatorAttachment>(r#""None""#).is_err());
325    /// # Ok::<_, serde_json::Error>(())
326    ///```
327    #[inline]
328    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
329    where
330        D: Deserializer<'de>,
331    {
332        /// `Visitor` for `AuthenticatorAttachment`.
333        struct AuthenticatorAttachmentVisitor;
334        impl Visitor<'_> for AuthenticatorAttachmentVisitor {
335            type Value = AuthenticatorAttachment;
336            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
337                formatter.write_str("AuthenticatorAttachment")
338            }
339            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
340            where
341                E: Error,
342            {
343                /// `"platform"`
344                const PLATFORM: &str = "platform";
345                /// `"cross-platform"`
346                const CROSS_PLATFORM: &str = "cross-platform";
347                match v {
348                    PLATFORM => Ok(AuthenticatorAttachment::Platform),
349                    CROSS_PLATFORM => Ok(AuthenticatorAttachment::CrossPlatform),
350                    _ => Err(E::invalid_value(
351                        Unexpected::Str(v),
352                        &format!("'{PLATFORM}' or '{CROSS_PLATFORM}'").as_str(),
353                    )),
354                }
355            }
356        }
357        deserializer.deserialize_str(AuthenticatorAttachmentVisitor)
358    }
359}
360/// Container of data that was encoded in base64url.
361pub(crate) struct Base64DecodedVal(pub Vec<u8>);
362impl<'de> Deserialize<'de> for Base64DecodedVal {
363    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
364    where
365        D: Deserializer<'de>,
366    {
367        /// `Visitor` for `Base64DecodedVal`.
368        struct Base64DecodedValVisitor;
369        impl Visitor<'_> for Base64DecodedValVisitor {
370            type Value = Base64DecodedVal;
371            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
372                formatter.write_str("base64url-encoded data")
373            }
374            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
375            where
376                E: Error,
377            {
378                base64url_nopad::decode(v.as_bytes())
379                    .map_err(E::custom)
380                    .map(Base64DecodedVal)
381            }
382        }
383        deserializer.deserialize_str(Base64DecodedValVisitor)
384    }
385}
386impl<'de> Deserialize<'de> for SentChallenge {
387    /// Deserializes `[u8]` or [`prim@str`] based on
388    /// [`challenge`](https://www.w3.org/TR/webauthn-3/#dom-collectedclientdata-challenge).
389    ///
390    /// Specifically a `[u8]` or `str` is base64url-decoded and interpreted as a little-endian
391    /// `u128`.
392    ///
393    /// # Examples
394    ///
395    /// ```
396    /// # use structured_webauthn::response::SentChallenge;
397    /// assert_eq!(
398    ///     serde_json::from_slice::<SentChallenge>(br#""AAAAAAAAAAAAAAAAAAAAAA""#)?,
399    ///     SentChallenge(0)
400    /// );
401    /// # Ok::<_, serde_json::Error>(())
402    ///```
403    #[inline]
404    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
405    where
406        D: Deserializer<'de>,
407    {
408        /// `Visitor` for `SentChallenge`.
409        struct ChallengeVisitor;
410        impl Visitor<'_> for ChallengeVisitor {
411            type Value = SentChallenge;
412            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
413                formatter.write_str(
414                    "base64 encoding of the 16-byte challenge in a URL safe way without padding",
415                )
416            }
417            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
418            where
419                E: Error,
420            {
421                if v.len() == Challenge::BASE64_LEN {
422                    let mut data = [0; 16];
423                    base64url_nopad::decode_buffer_exact(v, data.as_mut_slice())
424                        .map_err(E::custom)
425                        .map(|()| SentChallenge::from_array(data))
426                } else {
427                    Err(E::invalid_value(
428                        Unexpected::Bytes(v),
429                        &"22 bytes encoded in base64url without padding",
430                    ))
431                }
432            }
433            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
434            where
435                E: Error,
436            {
437                self.visit_bytes(v.as_bytes())
438            }
439        }
440        deserializer.deserialize_bytes(ChallengeVisitor)
441    }
442}
443impl<'de: 'a, 'a> Deserialize<'de> for Origin<'a> {
444    /// Deserializes [`prim@str`] by borrowing the data when possible.
445    ///
446    /// # Examples
447    ///
448    /// ```
449    /// # extern crate alloc;
450    /// # use alloc::borrow::Cow;
451    /// # use structured_webauthn::response::Origin;
452    /// let origin_borrowed = "https://example.com";
453    /// let origin_owned = "\\\\https://example.com";
454    /// assert!(
455    ///     matches!(serde_json::from_str::<Origin<'_>>(format!("\"{origin_borrowed}\"").as_str())?.0, Cow::Borrowed(val) if val == origin_borrowed)
456    /// );
457    /// assert!(
458    ///     matches!(serde_json::from_str::<Origin<'_>>(format!("\"{origin_owned}\"").as_str())?.0, Cow::Owned(val) if *val.as_bytes() == origin_owned.as_bytes()[1..])
459    /// );
460    /// # Ok::<_, serde_json::Error>(())
461    ///```
462    #[inline]
463    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
464    where
465        D: Deserializer<'de>,
466    {
467        /// `Visitor` for `Origin`.
468        struct OriginVisitor<'b>(PhantomData<fn() -> &'b ()>);
469        impl<'d: 'b, 'b> Visitor<'d> for OriginVisitor<'b> {
470            type Value = Origin<'b>;
471            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
472                formatter.write_str("Origin")
473            }
474            fn visit_borrowed_str<E>(self, v: &'d str) -> Result<Self::Value, E>
475            where
476                E: Error,
477            {
478                Ok(Origin(Cow::Borrowed(v)))
479            }
480            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
481            where
482                E: Error,
483            {
484                Ok(Origin(Cow::Owned(v)))
485            }
486            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
487            where
488                E: Error,
489            {
490                self.visit_string(v.to_owned())
491            }
492        }
493        deserializer.deserialize_str(OriginVisitor(PhantomData))
494    }
495}
496/// `trait` that returns an empty instance of `Self`.
497pub(super) trait ClientExtensions: Sized {
498    /// Returns an empty instance of `Self`.
499    fn empty() -> Self;
500}
501/// Response for both registration and authentication ceremonies.
502///
503/// [`Self::raw_id`] is always `Some` when `!RELAXED` or `!REG`.
504///
505/// `RELAXED` and `REG` are used purely for deserialization purposes.
506pub(super) struct PublicKeyCredential<const RELAXED: bool, const REG: bool, AuthResp, Ext> {
507    /// [`rawId`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-rawid).
508    pub id: Option<CredentialId<Box<[u8]>>>,
509    /// [`response`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-response).
510    pub response: AuthResp,
511    /// [`authenticatorAttachment`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-authenticatorattachment).
512    pub authenticator_attachment: AuthenticatorAttachment,
513    /// [`getClientExtensionResults`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-getclientextensionresults).
514    pub client_extension_results: Ext,
515}
516/// Deserializes the value for type.
517pub(crate) struct Type;
518impl<'e> Deserialize<'e> for Type {
519    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
520    where
521        D: Deserializer<'e>,
522    {
523        /// `Visitor` for `Type`.
524        struct TypeVisitor;
525        impl Visitor<'_> for TypeVisitor {
526            type Value = Type;
527            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
528                formatter.write_str(PUBLIC_KEY)
529            }
530            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
531            where
532                E: Error,
533            {
534                if v == PUBLIC_KEY {
535                    Ok(Type)
536                } else {
537                    Err(E::invalid_value(Unexpected::Str(v), &PUBLIC_KEY))
538                }
539            }
540        }
541        deserializer.deserialize_str(TypeVisitor)
542    }
543}
544/// `Visitor` for `PublicKeyCredential`.
545///
546/// When `!RELAXED`, `REG` is ignored and all fields must exist and unknown fields are not allowed.
547/// When `RELAXED`, unknown fields are ignored.
548/// When `RELAXED` and `REG`, only `response` is required.
549/// When `RELAXED` and `!REG`, only `id` and `response` are required.
550struct PublicKeyCredentialVisitor<const RELAXED: bool, const REG: bool, R, E>(
551    pub PhantomData<fn() -> (R, E)>,
552);
553impl<'d, const REL: bool, const REGI: bool, R, E> Visitor<'d>
554    for PublicKeyCredentialVisitor<REL, REGI, R, E>
555where
556    R: Deserialize<'d>,
557    E: for<'a> Deserialize<'a> + ClientExtensions,
558{
559    type Value = PublicKeyCredential<REL, REGI, R, E>;
560    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
561        formatter.write_str("PublicKeyCredential")
562    }
563    #[expect(
564        clippy::too_many_lines,
565        reason = "rather hide all the internal logic instead instead of moving into an outer scope"
566    )]
567    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
568    where
569        A: MapAccess<'d>,
570    {
571        /// `PublicKeyCredentialJSON` fields.
572        enum Field<const IGNORE_UNKNOWN: bool> {
573            /// `id`.
574            Id,
575            /// `type`.
576            Type,
577            /// `rawId`.
578            RawId,
579            /// `response`.
580            Response,
581            /// `authenticatorAttachment`.
582            AuthenticatorAttachment,
583            /// `clientExtensionResults`.
584            ClientExtensionResults,
585            /// Unknown field.
586            Other,
587        }
588        impl<'e, const IGNORE: bool> Deserialize<'e> for Field<IGNORE> {
589            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
590            where
591                D: Deserializer<'e>,
592            {
593                /// `Visitor` for `Field`.
594                struct FieldVisitor<const IGNORE_UNKNOWN: bool>;
595                impl<const IGN: bool> Visitor<'_> for FieldVisitor<IGN> {
596                    type Value = Field<IGN>;
597                    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
598                        write!(
599                            formatter,
600                            "'{ID}', '{TYPE}', '{RAW_ID}', '{RESPONSE}', '{AUTHENTICATOR_ATTACHMENT}', or '{CLIENT_EXTENSION_RESULTS}'"
601                        )
602                    }
603                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
604                    where
605                        E: Error,
606                    {
607                        match v {
608                            ID => Ok(Field::Id),
609                            TYPE => Ok(Field::Type),
610                            RAW_ID => Ok(Field::RawId),
611                            RESPONSE => Ok(Field::Response),
612                            AUTHENTICATOR_ATTACHMENT => Ok(Field::AuthenticatorAttachment),
613                            CLIENT_EXTENSION_RESULTS => Ok(Field::ClientExtensionResults),
614                            _ => {
615                                if IGN {
616                                    Ok(Field::Other)
617                                } else {
618                                    Err(E::unknown_field(v, REG_FIELDS))
619                                }
620                            }
621                        }
622                    }
623                }
624                deserializer.deserialize_identifier(FieldVisitor::<IGNORE>)
625            }
626        }
627        let mut opt_id = None;
628        let mut typ = false;
629        let mut raw = None;
630        let mut resp = None;
631        let mut attach = None;
632        let mut ext = None;
633        while let Some(key) = map.next_key::<Field<REL>>()? {
634            match key {
635                Field::Id => {
636                    if opt_id.is_some() {
637                        return Err(Error::duplicate_field(ID));
638                    }
639                    opt_id = map.next_value::<CredentialId<_>>().map(Some)?;
640                }
641                Field::Type => {
642                    if typ {
643                        return Err(Error::duplicate_field(TYPE));
644                    }
645                    typ = map.next_value::<Type>().map(|_| true)?;
646                }
647                Field::RawId => {
648                    if raw.is_some() {
649                        return Err(Error::duplicate_field(RAW_ID));
650                    }
651                    raw = map.next_value::<CredentialId<_>>().map(Some)?;
652                }
653                Field::Response => {
654                    if resp.is_some() {
655                        return Err(Error::duplicate_field(RESPONSE));
656                    }
657                    resp = map.next_value::<R>().map(Some)?;
658                }
659                Field::AuthenticatorAttachment => {
660                    if attach.is_some() {
661                        return Err(Error::duplicate_field(AUTHENTICATOR_ATTACHMENT));
662                    }
663                    attach = map.next_value().map(Some)?;
664                }
665                Field::ClientExtensionResults => {
666                    if ext.is_some() {
667                        return Err(Error::duplicate_field(CLIENT_EXTENSION_RESULTS));
668                    }
669                    ext = map.next_value::<Option<E>>().map(Some)?;
670                }
671                Field::Other => map.next_value::<IgnoredAny>().map(|_| ())?,
672            }
673        }
674        resp.ok_or_else(|| Error::missing_field(RESPONSE))
675            .and_then(|response| {
676                opt_id.map_or_else(
677                    || {
678                        if REL && REGI {
679                            Ok(None)
680                        } else {
681                            Err(Error::missing_field(ID))
682                        }
683                    },
684                    |id| Ok(Some(id)),
685                )
686                .and_then(|id| {
687                    raw.map_or_else(
688                        || {
689                            if REL {
690                                Ok(())
691                            } else {
692                                Err(Error::missing_field(RAW_ID))
693                            }
694                        },
695                        |raw_id| {
696                            id.as_ref().map_or_else(
697                                || Ok(()),
698                                |i| {
699                                    if raw_id == i {
700                                        Ok(())
701                                    } else {
702                                        Err(Error::invalid_value(
703                                            Unexpected::Bytes(raw_id.as_ref()),
704                                            &format!("{ID} and {RAW_ID} to match: {i:?}").as_str(),
705                                        ))
706                                    }
707                                },
708                            )
709                        }
710                    )
711                    .and_then(|()| {
712                        ext.ok_or(false).and_then(|opt_ext| opt_ext.ok_or(true)).map_or_else(
713                            |flag| {
714                                if REL {
715                                    Ok(E::empty())
716                                } else if flag {
717                                    Err(Error::invalid_type(Unexpected::Other("null"), &format!("{CLIENT_EXTENSION_RESULTS} to be a map of allowed client extensions").as_str()))
718                                } else {
719                                    Err(Error::missing_field(CLIENT_EXTENSION_RESULTS))
720                                }
721                            },
722                            Ok
723                        )
724                        .and_then(|client_extension_results| {
725                            if typ || REL {
726                                Ok(PublicKeyCredential {
727                                    id,
728                                    response,
729                                    authenticator_attachment: attach.flatten().unwrap_or(AuthenticatorAttachment::None),
730                                    client_extension_results,
731                                })
732                            } else {
733                                Err(Error::missing_field(TYPE))
734                            }
735                        })
736                    })
737                })
738            })
739    }
740}
741/// `"id"`.
742const ID: &str = "id";
743/// `"type"`.
744const TYPE: &str = "type";
745/// `"rawId"`.
746const RAW_ID: &str = "rawId";
747/// `"response"`.
748const RESPONSE: &str = "response";
749/// `"authenticatorAttachment"`.
750const AUTHENTICATOR_ATTACHMENT: &str = "authenticatorAttachment";
751/// `"clientExtensionResults"`.
752const CLIENT_EXTENSION_RESULTS: &str = "clientExtensionResults";
753/// `"public-key"`.
754const PUBLIC_KEY: &str = "public-key";
755/// Fields for `PublicKeyCredentialJSON`.
756const REG_FIELDS: &[&str; 6] = &[
757    ID,
758    TYPE,
759    RAW_ID,
760    RESPONSE,
761    AUTHENTICATOR_ATTACHMENT,
762    CLIENT_EXTENSION_RESULTS,
763];
764impl<'de, const REL: bool, const REGI: bool, R, E> Deserialize<'de>
765    for PublicKeyCredential<REL, REGI, R, E>
766where
767    R: Deserialize<'de>,
768    E: for<'a> Deserialize<'a> + ClientExtensions,
769{
770    /// Deserializes a `struct` based on
771    /// [`PublicKeyCredentialJSON`](https://www.w3.org/TR/webauthn-3/#typedefdef-publickeycredentialjson).
772    ///
773    /// `REL` iff unknown fields should be ignored and not cause an error.
774    /// `REGI` iff `Self` is from a registration ceremony.
775    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
776    where
777        D: Deserializer<'de>,
778    {
779        deserializer.deserialize_struct(
780            "PublicKeyCredential",
781            REG_FIELDS,
782            PublicKeyCredentialVisitor::<REL, REGI, _, _>(PhantomData),
783        )
784    }
785}
786use super::UserHandle;
787impl<const USER_LEN: usize> Serialize for AllAcceptedCredentialsOptions<'_, '_, USER_LEN>
788where
789    UserHandle<USER_LEN>: Serialize,
790{
791    /// Serializes `self` to conform with
792    /// [`AllAcceptedCredentialsOptions`](https://www.w3.org/TR/webauthn-3/#dictdef-allacceptedcredentialsoptions).
793    ///
794    /// # Examples
795    ///
796    /// ```
797    /// # use core::str::FromStr;
798    /// # #[cfg(feature = "bin")]
799    /// # use structured_webauthn::bin::Decode;
800    /// # use structured_webauthn::{
801    /// #     request::{register::{UserHandle, USER_HANDLE_MIN_LEN}, AsciiDomain, RpId},
802    /// #     response::{error::CredentialIdErr, AllAcceptedCredentialsOptions, CredentialId},
803    /// # };
804    /// /// Retrieves the `CredentialId`s associated with `user_id` from the database.
805    /// # #[cfg(all(feature = "bin", feature = "custom"))]
806    /// fn get_credential_ids(user_id: UserHandle<USER_HANDLE_MIN_LEN>) -> Result<Vec<CredentialId<Box<[u8]>>>, CredentialIdErr> {
807    ///     // ⋮
808    /// #     CredentialId::decode(vec![0; 16].into_boxed_slice()).map(|cred_id| vec![cred_id])
809    /// }
810    /// /// Retrieves the `UserHandle` from a session cookie.
811    /// # #[cfg(feature = "custom")]
812    /// fn get_user_handle() -> UserHandle<USER_HANDLE_MIN_LEN> {
813    ///     // ⋮
814    /// #     [0].into()
815    /// }
816    /// # #[cfg(feature = "custom")]
817    /// let user_id = get_user_handle();
818    /// # #[cfg(all(feature = "bin", feature = "custom"))]
819    /// assert_eq!(
820    ///     serde_json::to_string(&AllAcceptedCredentialsOptions {
821    ///         rp_id: &RpId::Domain(AsciiDomain::try_from("example.com".to_owned())?),
822    ///         user_id: &user_id,
823    ///         all_accepted_credential_ids: get_credential_ids(user_id)?,
824    ///     })
825    ///     .unwrap(),
826    ///     r#"{"rpId":"example.com","userId":"AA","allAcceptedCredentialIds":["AAAAAAAAAAAAAAAAAAAAAA"]}"#
827    /// );
828    /// # Ok::<_, structured_webauthn::AggErr>(())
829    /// ```
830    #[inline]
831    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
832    where
833        S: Serializer,
834    {
835        serializer
836            .serialize_struct("AllAcceptedCredentialsOptions", 3)
837            .and_then(|mut ser| {
838                ser.serialize_field("rpId", self.rp_id).and_then(|()| {
839                    ser.serialize_field("userId", &self.user_id).and_then(|()| {
840                        ser.serialize_field(
841                            "allAcceptedCredentialIds",
842                            &self.all_accepted_credential_ids,
843                        )
844                        .and_then(|()| ser.end())
845                    })
846                })
847            })
848    }
849}
850impl<const LEN: usize> Serialize for CurrentUserDetailsOptions<'_, '_, '_, '_, LEN>
851where
852    UserHandle<LEN>: Serialize,
853{
854    /// Serializes `self` to conform with
855    /// [`CurrentUserDetailsOptions`](https://www.w3.org/TR/webauthn-3/#dictdef-currentuserdetailsoptions).
856    ///
857    /// # Examples
858    ///
859    /// ```
860    /// # use core::str::FromStr;
861    /// # #[cfg(feature = "bin")]
862    /// # use structured_webauthn::bin::Decode;
863    /// # use structured_webauthn::{
864    /// #     request::{register::{PublicKeyCredentialUserEntity, UserHandle, USER_HANDLE_MIN_LEN}, AsciiDomain, RpId},
865    /// #     response::CurrentUserDetailsOptions,
866    /// #     AggErr,
867    /// # };
868    /// /// Retrieves the `PublicKeyCredentialUserEntity` info associated with `user_id` from the database.
869    /// # #[cfg(feature = "bin")]
870    /// fn get_user_info(user_id: UserHandle<USER_HANDLE_MIN_LEN>) -> Result<(String, String), AggErr> {
871    ///     // ⋮
872    /// #     Ok(("foo".to_owned(), "foo".to_owned()))
873    /// }
874    /// /// Retrieves the `UserHandle` from a session cookie.
875    /// # #[cfg(feature = "custom")]
876    /// fn get_user_handle() -> UserHandle<USER_HANDLE_MIN_LEN> {
877    ///     // ⋮
878    /// #     [0].into()
879    /// }
880    /// # #[cfg(feature = "custom")]
881    /// let user_handle = get_user_handle();
882    /// # #[cfg(all(feature = "bin", feature = "custom"))]
883    /// let (name, display_name) = get_user_info(user_handle)?;
884    /// # #[cfg(all(feature = "bin", feature = "custom"))]
885    /// assert_eq!(
886    ///     serde_json::to_string(&CurrentUserDetailsOptions {
887    ///         rp_id: &RpId::Domain(AsciiDomain::try_from("example.com".to_owned())?),
888    ///         user: PublicKeyCredentialUserEntity { name: &name, id: &user_handle, display_name: &display_name, },
889    ///     })
890    ///     .unwrap(),
891    ///     r#"{"rpId":"example.com","userId":"AA","name":"foo","displayName":"foo"}"#
892    /// );
893    /// # Ok::<_, AggErr>(())
894    /// ```
895    #[inline]
896    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
897    where
898        S: Serializer,
899    {
900        serializer
901            .serialize_struct("CurrentUserDetailsOptions", 4)
902            .and_then(|mut ser| {
903                ser.serialize_field("rpId", self.rp_id).and_then(|()| {
904                    ser.serialize_field("userId", &self.user.id).and_then(|()| {
905                        ser.serialize_field("name", &self.user.name).and_then(|()| {
906                            ser.serialize_field("displayName", &self.user.display_name)
907                                .and_then(|()| ser.end())
908                        })
909                    })
910                })
911            })
912    }
913}
914/// JSON `null`.
915pub(crate) struct Null;
916impl<'de> Deserialize<'de> for Null {
917    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
918    where
919        D: Deserializer<'de>,
920    {
921        /// `Visitor` for `Null`.
922        struct NullVisitor;
923        impl Visitor<'_> for NullVisitor {
924            type Value = Null;
925            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
926                formatter.write_str("null")
927            }
928            fn visit_none<E>(self) -> Result<Self::Value, E>
929            where
930                E: Error,
931            {
932                Ok(Null)
933            }
934        }
935        deserializer.deserialize_option(NullVisitor)
936    }
937}
938/// [`AuthenticationExtensionsPRFValues`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsprfvalues).
939pub(super) struct AuthenticationExtensionsPrfValues;
940/// `Visitor` for `AuthenticationExtensionsPrfValues`.
941///
942/// Unknown fields are ignored iff `RELAXED`.`first` must always exist if `second` does.
943/// `first` and `second` must be `null` if they exist. `first` must exist iff `!RELAXED`.
944pub(super) struct AuthenticationExtensionsPrfValuesVisitor<const RELAXED: bool>;
945impl<'d, const R: bool> Visitor<'d> for AuthenticationExtensionsPrfValuesVisitor<R> {
946    type Value = AuthenticationExtensionsPrfValues;
947    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
948        formatter.write_str("AuthenticationExtensionsPrfValues")
949    }
950    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
951    where
952        A: MapAccess<'d>,
953    {
954        /// Fields.
955        enum Field<const IGNORE_UNKNOWN: bool> {
956            /// `first` field.
957            First,
958            /// `second` field.
959            Second,
960            /// Unknown field.
961            Other,
962        }
963        impl<'e, const I: bool> Deserialize<'e> for Field<I> {
964            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
965            where
966                D: Deserializer<'e>,
967            {
968                /// `Visitor` for `Field`.
969                ///
970                /// Unknown fields are ignored iff `IGNORE_UNKNOWN`.
971                struct FieldVisitor<const IGNORE_UNKNOWN: bool>;
972                impl<const IG: bool> Visitor<'_> for FieldVisitor<IG> {
973                    type Value = Field<IG>;
974                    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
975                        write!(formatter, "'{FIRST}' or '{SECOND}'")
976                    }
977                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
978                    where
979                        E: Error,
980                    {
981                        match v {
982                            FIRST => Ok(Field::First),
983                            SECOND => Ok(Field::Second),
984                            _ => {
985                                if IG {
986                                    Ok(Field::Other)
987                                } else {
988                                    Err(E::unknown_field(v, PRF_VALUES_FIELDS))
989                                }
990                            }
991                        }
992                    }
993                }
994                deserializer.deserialize_identifier(FieldVisitor)
995            }
996        }
997        let mut first = None;
998        let mut second = None;
999        while let Some(key) = map.next_key::<Field<R>>()? {
1000            match key {
1001                Field::First => {
1002                    if first.is_some() {
1003                        return Err(Error::duplicate_field(FIRST));
1004                    }
1005                    first = map.next_value::<Null>().map(Some)?;
1006                }
1007                Field::Second => {
1008                    if second.is_some() {
1009                        return Err(Error::duplicate_field(SECOND));
1010                    }
1011                    second = map.next_value::<Null>().map(Some)?;
1012                }
1013                Field::Other => map.next_value::<IgnoredAny>().map(|_| ())?,
1014            }
1015        }
1016        if first.is_some() || (R && second.is_none()) {
1017            Ok(AuthenticationExtensionsPrfValues)
1018        } else {
1019            Err(Error::missing_field(FIRST))
1020        }
1021    }
1022}
1023/// `"first"`
1024const FIRST: &str = "first";
1025/// `"second"`
1026const SECOND: &str = "second";
1027/// `AuthenticationExtensionsPrfValues` fields.
1028pub(super) const PRF_VALUES_FIELDS: &[&str; 2] = &[FIRST, SECOND];
1029impl<'de> Deserialize<'de> for AuthenticationExtensionsPrfValues {
1030    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1031    where
1032        D: Deserializer<'de>,
1033    {
1034        deserializer.deserialize_struct(
1035            "AuthenticationExtensionsPrfValues",
1036            PRF_VALUES_FIELDS,
1037            AuthenticationExtensionsPrfValuesVisitor::<false>,
1038        )
1039    }
1040}
1041/// [`AuthenticationExtensionsPRFOutputs`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsprfoutputs).
1042///
1043/// `RELAXED` iff unknown fields are ignored.
1044///
1045/// `REGISTRATION` iff
1046/// [`enabled`](https://www.w3.org/TR/webauthn-3/#dom-authenticationextensionsprfoutputs-enabled)
1047/// is required (and must not be `null`); otherwise it's forbidden.
1048///
1049/// The contained `Option` is `Some` iff `REGISTRATION`.
1050pub(super) struct AuthenticationExtensionsPrfOutputsHelper<
1051    const RELAXED: bool,
1052    const REGISTRATION: bool,
1053    Prf,
1054>(pub Option<bool>, pub PhantomData<fn() -> Prf>);
1055/// `Visitor` for `AuthenticationExtensionsPrfOutputs`.
1056///
1057/// Unknown fields are ignored iff `RELAXED`.`enabled` must exist and not be `null` iff `REGISTRATION`.
1058struct AuthenticationExtensionsPrfOutputsVisitor<const RELAXED: bool, const REGISTRATION: bool, Prf>(
1059    PhantomData<fn() -> Prf>,
1060);
1061impl<'d, const REL: bool, const REG: bool, Prf> Visitor<'d>
1062    for AuthenticationExtensionsPrfOutputsVisitor<REL, REG, Prf>
1063where
1064    Prf: for<'a> Deserialize<'a>,
1065{
1066    type Value = AuthenticationExtensionsPrfOutputsHelper<REL, REG, Prf>;
1067    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1068        formatter.write_str("AuthenticationExtensionsPrfOutputs")
1069    }
1070    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1071    where
1072        A: MapAccess<'d>,
1073    {
1074        /// Fields.
1075        enum Field<const IGNORE_UNKNOWN: bool, const REGI: bool> {
1076            /// `enabled` field.
1077            Enabled,
1078            /// `results` field.
1079            Results,
1080            /// Unknown field.
1081            Other,
1082        }
1083        impl<'e, const I: bool, const R: bool> Deserialize<'e> for Field<I, R> {
1084            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1085            where
1086                D: Deserializer<'e>,
1087            {
1088                /// `Visitor` for `Field`.
1089                ///
1090                /// Unknown fields are ignored iff `IGNORE_UNKNOWN`.
1091                /// `enabled` is allowed to exist iff `REGI`.
1092                struct FieldVisitor<const IGNORE_UNKNOWN: bool, const REGI: bool>;
1093                impl<const IG: bool, const RE: bool> Visitor<'_> for FieldVisitor<IG, RE> {
1094                    type Value = Field<IG, RE>;
1095                    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1096                        if RE {
1097                            write!(formatter, "'{ENABLED}' or '{RESULTS}'")
1098                        } else {
1099                            write!(formatter, "'{RESULTS}'")
1100                        }
1101                    }
1102                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1103                    where
1104                        E: Error,
1105                    {
1106                        match v {
1107                            ENABLED => {
1108                                if RE {
1109                                    Ok(Field::Enabled)
1110                                } else {
1111                                    Err(E::unknown_field(v, PRF_AUTH_OUTPUTS_FIELDS))
1112                                }
1113                            }
1114                            RESULTS => Ok(Field::Results),
1115                            _ => {
1116                                if IG {
1117                                    Ok(Field::Other)
1118                                } else if RE {
1119                                    Err(E::unknown_field(v, PRF_REG_OUTPUTS_FIELDS))
1120                                } else {
1121                                    Err(E::unknown_field(v, PRF_AUTH_OUTPUTS_FIELDS))
1122                                }
1123                            }
1124                        }
1125                    }
1126                }
1127                deserializer.deserialize_identifier(FieldVisitor)
1128            }
1129        }
1130        let mut enabled = None;
1131        let mut results = None;
1132        while let Some(key) = map.next_key::<Field<REL, REG>>()? {
1133            match key {
1134                Field::Enabled => {
1135                    if enabled.is_some() {
1136                        return Err(Error::duplicate_field(ENABLED));
1137                    }
1138                    enabled = map.next_value().map(Some)?;
1139                }
1140                Field::Results => {
1141                    if results.is_some() {
1142                        return Err(Error::duplicate_field(RESULTS));
1143                    }
1144                    results = map.next_value::<Option<Prf>>().map(Some)?;
1145                }
1146                Field::Other => map.next_value::<IgnoredAny>().map(|_| ())?,
1147            }
1148        }
1149        if REG {
1150            enabled.ok_or_else(|| Error::missing_field(ENABLED)).and_then(|e| {
1151                if e || results.is_none() {
1152                    Ok(())
1153                } else {
1154                    Err(Error::custom("prf must not have 'results', including a null 'results', if 'enabled' is false"))
1155                }
1156            })
1157        } else {
1158            Ok(())
1159        }.map(|()| AuthenticationExtensionsPrfOutputsHelper(enabled, PhantomData))
1160    }
1161}
1162/// `"enabled"`
1163const ENABLED: &str = "enabled";
1164/// `"results"`
1165const RESULTS: &str = "results";
1166/// `AuthenticationExtensionsPrfOutputs` field during registration.
1167const PRF_REG_OUTPUTS_FIELDS: &[&str; 2] = &[ENABLED, RESULTS];
1168/// `AuthenticationExtensionsPrfOutputs` field during authentication.
1169const PRF_AUTH_OUTPUTS_FIELDS: &[&str; 1] = &[RESULTS];
1170impl<'de, const REL: bool, const REG: bool, Prf> Deserialize<'de>
1171    for AuthenticationExtensionsPrfOutputsHelper<REL, REG, Prf>
1172where
1173    for<'a> Prf: Deserialize<'a>,
1174{
1175    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1176    where
1177        D: Deserializer<'de>,
1178    {
1179        deserializer.deserialize_struct(
1180            "AuthenticationExtensionsPrfOutputs",
1181            if REG {
1182                PRF_REG_OUTPUTS_FIELDS
1183            } else {
1184                PRF_AUTH_OUTPUTS_FIELDS
1185            },
1186            AuthenticationExtensionsPrfOutputsVisitor::<REL, REG, Prf>(PhantomData),
1187        )
1188    }
1189}