Trait amadeus_types::__internal::Deserialize

pub trait Deserialize<'de> {
    fn deserialize<D>(
        deserializer: D
    ) -> Result<Self, <D as Deserializer<'de>>::Error>
    where
        D: Deserializer<'de>;
}

A data structure that can be deserialized from any data format supported by Serde.

Serde provides Deserialize implementations for many Rust primitive and standard library types. The complete list is here. All of these can be deserialized using Serde out of the box.

Additionally, Serde provides a procedural macro called serde_derive to automatically generate Deserialize implementations for structs and enums in your program. See the derive section of the manual for how to use this.

In rare cases it may be necessary to implement Deserialize manually for some type in your program. See the Implementing Deserialize section of the manual for more about this.

Third-party crates may provide Deserialize implementations for types that they expose. For example the linked-hash-map crate provides a LinkedHashMap<K, V> type that is deserializable by Serde because the crate provides an implementation of Deserialize for it.

Lifetime

The 'de lifetime of this trait is the lifetime of data that may be borrowed by Self when deserialized. See the page Understanding deserializer lifetimes for a more detailed explanation of these lifetimes.

Required methods

fn deserialize<D>(
    deserializer: D
) -> Result<Self, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

See the Implementing Deserialize section of the manual for more information about how to implement this method.

Loading content...

Implementations on Foreign Types

impl<'de> Deserialize<'de> for i32

fn deserialize<D>(
    deserializer: D
) -> Result<i32, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 20] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 20], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 20]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 10] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 10], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 10]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T10: Deserialize<'de>,
    T11: Deserialize<'de>,
    T12: Deserialize<'de>,
    T13: Deserialize<'de>,
    T14: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>,
    T9: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx> where
    Idx: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<RangeInclusive<Idx>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicI32

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI32, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Box<Path>

fn deserialize<D>(
    deserializer: D
) -> Result<Box<Path>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 11] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 11], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 11]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for i128

fn deserialize<D>(
    deserializer: D
) -> Result<i128, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 29] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 29], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 29]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Ipv6Addr

fn deserialize<D>(
    deserializer: D
) -> Result<Ipv6Addr, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5> Deserialize<'de> for (T0, T1, T2, T3, T4, T5) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroI64

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI64, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for bool

fn deserialize<D>(
    deserializer: D
) -> Result<bool, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for usize

fn deserialize<D>(
    deserializer: D
) -> Result<usize, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T10: Deserialize<'de>,
    T11: Deserialize<'de>,
    T12: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>,
    T9: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 23] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 23], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 23]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T10: Deserialize<'de>,
    T11: Deserialize<'de>,
    T12: Deserialize<'de>,
    T13: Deserialize<'de>,
    T14: Deserialize<'de>,
    T15: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>,
    T9: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 5] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 5], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 5]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for i16

fn deserialize<D>(
    deserializer: D
) -> Result<i16, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 28] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 28], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 28]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 4] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 4], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 4]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroU64

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroU64, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for u32

fn deserialize<D>(
    deserializer: D
) -> Result<u32, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroU32

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroU32, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicU16

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicU16, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for u128

fn deserialize<D>(
    deserializer: D
) -> Result<u128, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for BTreeSet<T> where
    T: Deserialize<'de> + Eq + Ord, 

fn deserialize<D>(
    deserializer: D
) -> Result<BTreeSet<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut BTreeSet<T>
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3> Deserialize<'de> for (T0, T1, T2, T3) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 30] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 30], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 30]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicI64

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI64, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 8] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 8], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 8]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicIsize

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicIsize, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 13] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 13], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 13]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for u16

fn deserialize<D>(
    deserializer: D
) -> Result<u16, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicI8

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI8, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T10: Deserialize<'de>,
    T11: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>,
    T9: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for OsString

fn deserialize<D>(
    deserializer: D
) -> Result<OsString, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for VecDeque<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<VecDeque<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut VecDeque<T>
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for SocketAddrV6

fn deserialize<D>(
    deserializer: D
) -> Result<SocketAddrV6, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicI16

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI16, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 18] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 18], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 18]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for u8

fn deserialize<D>(
    deserializer: D
) -> Result<u8, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicU64

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicU64, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for SocketAddrV4

fn deserialize<D>(
    deserializer: D
) -> Result<SocketAddrV4, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 27] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 27], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 27]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroIsize

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroIsize, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicUsize

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicUsize, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, 'a> Deserialize<'de> for &'a [u8] where
    'de: 'a, 

fn deserialize<D>(
    deserializer: D
) -> Result<&'a [u8], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>,
    T9: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 14] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 14], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 14]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for ()

fn deserialize<D>(
    deserializer: D
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T, E> Deserialize<'de> for Result<T, E> where
    E: Deserialize<'de>,
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Result<T, E>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for SystemTime

fn deserialize<D>(
    deserializer: D
) -> Result<SystemTime, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4> Deserialize<'de> for (T0, T1, T2, T3, T4) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0> Deserialize<'de> for (T0,) where
    T0: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0,), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0,)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Mutex<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Mutex<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroI128

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI128, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 24] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 24], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 24]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroU8

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroU8, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 32] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 32], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 32]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroI8

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI8, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for PathBuf

fn deserialize<D>(
    deserializer: D
) -> Result<PathBuf, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T10: Deserialize<'de>,
    T11: Deserialize<'de>,
    T12: Deserialize<'de>,
    T13: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>,
    T9: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 16] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 16], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 16]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Box<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Box<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, K, V> Deserialize<'de> for BTreeMap<K, V> where
    K: Deserialize<'de> + Ord,
    V: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<BTreeMap<K, V>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Box<CStr>

fn deserialize<D>(
    deserializer: D
) -> Result<Box<CStr>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for i64

fn deserialize<D>(
    deserializer: D
) -> Result<i64, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Wrapping<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Wrapping<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Cell<T> where
    T: Deserialize<'de> + Copy, 

fn deserialize<D>(
    deserializer: D
) -> Result<Cell<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 19] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 19], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 19]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for LinkedList<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<LinkedList<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut LinkedList<T>
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for f64

fn deserialize<D>(
    deserializer: D
) -> Result<f64, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for isize

fn deserialize<D>(
    deserializer: D
) -> Result<isize, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 31] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 31], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 31]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroUsize

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroUsize, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 21] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 21], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 21]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Bound<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Bound<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T, S> Deserialize<'de> for HashSet<T, S> where
    S: BuildHasher + Default,
    T: Deserialize<'de> + Eq + Hash, 

fn deserialize<D>(
    deserializer: D
) -> Result<HashSet<T, S>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut HashSet<T, S>
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for i8

fn deserialize<D>(
    deserializer: D
) -> Result<i8, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, K, V, S> Deserialize<'de> for HashMap<K, V, S> where
    K: Deserialize<'de> + Eq + Hash,
    S: BuildHasher + Default,
    V: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<HashMap<K, V, S>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicU32

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicU32, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Box<str>

fn deserialize<D>(
    deserializer: D
) -> Result<Box<str>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 26] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 26], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 26]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 17] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 17], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 17]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for char

fn deserialize<D>(
    deserializer: D
) -> Result<char, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicU8

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicU8, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 12] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 12], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 12]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroU16

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroU16, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for IgnoredAny

fn deserialize<D>(
    deserializer: D
) -> Result<IgnoredAny, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroU128

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroU128, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 6] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 6], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 6]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Box<[T]> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Box<[T]>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 0]

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 0], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 1] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 1], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 1]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroI16

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI16, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NonZeroI32

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI32, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for u64

fn deserialize<D>(
    deserializer: D
) -> Result<u64, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Option<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Option<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Duration

fn deserialize<D>(
    deserializer: D
) -> Result<Duration, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 22] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 22], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 22]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for CString

fn deserialize<D>(
    deserializer: D
) -> Result<CString, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for String

fn deserialize<D>(
    deserializer: D
) -> Result<String, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut String
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for SocketAddr

fn deserialize<D>(
    deserializer: D
) -> Result<SocketAddr, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for PhantomData<T> where
    T: ?Sized, 

fn deserialize<D>(
    deserializer: D
) -> Result<PhantomData<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for AtomicBool

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicBool, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for BinaryHeap<T> where
    T: Deserialize<'de> + Ord, 

fn deserialize<D>(
    deserializer: D
) -> Result<BinaryHeap<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut BinaryHeap<T>
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for f32

fn deserialize<D>(
    deserializer: D
) -> Result<f32, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, 'a> Deserialize<'de> for &'a Path where
    'de: 'a, 

fn deserialize<D>(
    deserializer: D
) -> Result<&'a Path, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, 'a> Deserialize<'de> for &'a str where
    'de: 'a, 

fn deserialize<D>(
    deserializer: D
) -> Result<&'a str, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Ipv4Addr

fn deserialize<D>(
    deserializer: D
) -> Result<Ipv4Addr, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for RwLock<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<RwLock<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Reverse<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Reverse<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 7] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 7], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 7]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 25] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 25], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 25]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, Idx> Deserialize<'de> for Range<Idx> where
    Idx: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Range<Idx>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2> Deserialize<'de> for (T0, T1, T2) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T2: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 2] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 2], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 2]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for RefCell<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<RefCell<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1> Deserialize<'de> for (T0, T1) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 9] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 9], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 9]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T0: Deserialize<'de>,
    T1: Deserialize<'de>,
    T10: Deserialize<'de>,
    T2: Deserialize<'de>,
    T3: Deserialize<'de>,
    T4: Deserialize<'de>,
    T5: Deserialize<'de>,
    T6: Deserialize<'de>,
    T7: Deserialize<'de>,
    T8: Deserialize<'de>,
    T9: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, 'a, T> Deserialize<'de> for Cow<'a, T> where
    T: ToOwned + ?Sized,
    <T as ToOwned>::Owned: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Cow<'a, T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 15] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 15], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 15]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for [T; 3] where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<[T; 3], <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut [T; 3]
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for Vec<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Vec<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut Vec<T>
) -> Result<(), <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, S> Deserialize<'de> for Host<S> where
    S: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Host<S>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, T> Deserialize<'de> for PushReducer<A, T>

fn deserialize<__D>(
    __deserializer: __D
) -> Result<PushReducer<A, T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for ReduceC0

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC0, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, C, F> Deserialize<'de> for FilterTask<C, F> where
    C: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FilterTask<C, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F> Deserialize<'de> for ReduceA6<A, B, C, D, E, F> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA6<A, B, C, D, E, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, F> Deserialize<'de> for AllReducerAsync<A, F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AllReducerAsync<A, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F> Deserialize<'de> for ReduceC6<A, B, C, D, E, F> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC6<A, B, C, D, E, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, F, A> Deserialize<'de> for ReduceFn<F, A> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceFn<F, A>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for ReduceA0

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA0, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, T, F> Deserialize<'de> for InspectTask<T, F> where
    F: Deserialize<'de>,
    T: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<InspectTask<T, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for BoolAndReducer

fn deserialize<__D>(
    __deserializer: __D
) -> Result<BoolAndReducer, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, ID, F, B, Step> Deserialize<'de> for FoldFolder<A, ID, F, B, Step> where
    F: Deserialize<'de>,
    ID: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FoldFolder<A, ID, F, B, Step>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Serde<Error>

fn deserialize<D>(
    deserializer: D
) -> Result<Serde<Error>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, A, B, C, D> Deserialize<'de> for ReduceA4<A, B, C, D> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA4<A, B, C, D>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C> Deserialize<'de> for ReduceA3<A, B, C> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA3<A, B, C>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Serde<ErrorKind>

fn deserialize<D>(
    deserializer: D
) -> Result<Serde<ErrorKind>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, A, B, C, D> Deserialize<'de> for ReduceC4<A, B, C, D> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC4<A, B, C, D>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E> Deserialize<'de> for ReduceC5<A, B, C, D, E> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC5<A, B, C, D, E>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for IoError

fn deserialize<__D>(
    __deserializer: __D
) -> Result<IoError, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, F> Deserialize<'de> for AnyReducerAsync<A, F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AnyReducerAsync<A, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, F> Deserialize<'de> for ForEachReducer<A, F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ForEachReducer<A, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for SampleUnstableFolder

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SampleUnstableFolder, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B> Deserialize<'de> for ChainTask<A, B> where
    A: Deserialize<'de>,
    B: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ChainTask<A, B>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G> Deserialize<'de> for ReduceC7<A, B, C, D, E, F, G> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC7<A, B, C, D, E, F, G>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A> Deserialize<'de> for ReduceA1<A> where
    A: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA1<A>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C> Deserialize<'de> for ReduceC3<A, B, C> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC3<A, B, C>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for MostDistinctFolder

fn deserialize<__D>(
    __deserializer: __D
) -> Result<MostDistinctFolder, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for BoolOrReducerAsync

fn deserialize<__D>(
    __deserializer: __D
) -> Result<BoolOrReducerAsync, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, C> Deserialize<'de> for FolderSyncReducer<A, C> where
    C: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FolderSyncReducer<A, C>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B> Deserialize<'de> for ReduceC2<A, B> where
    A: Deserialize<'de>,
    B: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC2<A, B>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, T, F> Deserialize<'de> for UpdateTask<T, F> where
    F: Deserialize<'de>,
    T: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<UpdateTask<T, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, P, R, T, U> Deserialize<'de> for GroupByReducerA<P, R, T, U> where
    P: Deserialize<'de>,
    R: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<GroupByReducerA<P, R, T, U>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, R, T, U> Deserialize<'de> for GroupByReducerB<R, T, U> where
    R: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<GroupByReducerB<R, T, U>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H> Deserialize<'de> for ReduceA8<A, B, C, D, E, F, G, H> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA8<A, B, C, D, E, F, G, H>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for ClonedTask<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ClonedTask<T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H> Deserialize<'de> for ReduceC8<A, B, C, D, E, F, G, H> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC8<A, B, C, D, E, F, G, H>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B> Deserialize<'de> for ReduceA2<A, B> where
    A: Deserialize<'de>,
    B: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA2<A, B>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for IdentityTask

fn deserialize<__D>(
    __deserializer: __D
) -> Result<IdentityTask, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for MostFrequentFolder

fn deserialize<__D>(
    __deserializer: __D
) -> Result<MostFrequentFolder, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, B, Step> Deserialize<'de> for HistogramFolder<B, Step>

fn deserialize<__D>(
    __deserializer: __D
) -> Result<HistogramFolder<B, Step>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, C, F> Deserialize<'de> for MapTask<C, F> where
    C: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<MapTask<C, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, C, F> Deserialize<'de> for FlatMapTask<C, F> where
    C: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FlatMapTask<C, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, F> Deserialize<'de> for AnyReducer<A, F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AnyReducer<A, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E> Deserialize<'de> for ReduceA5<A, B, C, D, E> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA5<A, B, C, D, E>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Never

fn deserialize<D>(
    _deserializer: D
) -> Result<Never, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for IterStreamTask<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<IterStreamTask<T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, B> Deserialize<'de> for SumZeroFolder<B> where
    B: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SumZeroFolder<B>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for BoolOrReducer

fn deserialize<__D>(
    __deserializer: __D
) -> Result<BoolOrReducer, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A> Deserialize<'de> for ReduceC1<A> where
    A: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceC1<A>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G> Deserialize<'de> for ReduceA7<A, B, C, D, E, F, G> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ReduceA7<A, B, C, D, E, F, G>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, R, T> Deserialize<'de> for IntoReducer<R, T> where
    R: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<IntoReducer<R, T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, T> Deserialize<'de> for ExtendReducer<A, T>

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ExtendReducer<A, T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, B> Deserialize<'de> for SumFolder<B>

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SumFolder<B>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, R, E> Deserialize<'de> for ResultReducer<R, E> where
    R: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ResultReducer<R, E>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, R> Deserialize<'de> for OptionReducer<R> where
    R: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<OptionReducer<R>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Serde<Arc<Error>>

fn deserialize<D>(
    deserializer: D
) -> Result<Serde<Arc<Error>>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, A, F> Deserialize<'de> for AllReducer<A, F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AllReducer<A, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for CountFolder

fn deserialize<__D>(
    __deserializer: __D
) -> Result<CountFolder, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, L, R> Deserialize<'de> for Either<L, R> where
    L: Deserialize<'de>,
    R: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Either<L, R>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, F> Deserialize<'de> for Fn<F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Fn<F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, F> Deserialize<'de> for FnMut<F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FnMut<F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, F> Deserialize<'de> for FnOnce<F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FnOnce<F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B> Deserialize<'de> for Sum2<A, B> where
    A: Deserialize<'de>,
    B: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum2<A, B>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Deserialize<'de> for Sum18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F> Deserialize<'de> for Sum6<A, B, C, D, E, F> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum6<A, B, C, D, E, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Deserialize<'de> for Sum23<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum23<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Deserialize<'de> for Sum26<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum26<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C> Deserialize<'de> for Sum3<A, B, C> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum3<A, B, C>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M> Deserialize<'de> for Sum13<A, B, C, D, E, F, G, H, I, J, K, L, M> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum13<A, B, C, D, E, F, G, H, I, J, K, L, M>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Sum0

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum0, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Deserialize<'de> for Sum19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Deserialize<'de> for Sum15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H> Deserialize<'de> for Sum8<A, B, C, D, E, F, G, H> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum8<A, B, C, D, E, F, G, H>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa> Deserialize<'de> for Sum27<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa> where
    A: Deserialize<'de>,
    Aa: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum27<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Deserialize<'de> for Sum14<A, B, C, D, E, F, G, H, I, J, K, L, M, N> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K> Deserialize<'de> for Sum11<A, B, C, D, E, F, G, H, I, J, K> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum11<A, B, C, D, E, F, G, H, I, J, K>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae> Deserialize<'de> for Sum31<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae> where
    A: Deserialize<'de>,
    Aa: Deserialize<'de>,
    Ab: Deserialize<'de>,
    Ac: Deserialize<'de>,
    Ad: Deserialize<'de>,
    Ae: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum31<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G> Deserialize<'de> for Sum7<A, B, C, D, E, F, G> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum7<A, B, C, D, E, F, G>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Deserialize<'de> for Sum24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Deserialize<'de> for Sum16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Deserialize<'de> for Sum21<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum21<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> Deserialize<'de> for Sum25<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum25<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Deserialize<'de> for Sum17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E> Deserialize<'de> for Sum5<A, B, C, D, E> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum5<A, B, C, D, E>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Deserialize<'de> for Sum22<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum22<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L> Deserialize<'de> for Sum12<A, B, C, D, E, F, G, H, I, J, K, L> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum12<A, B, C, D, E, F, G, H, I, J, K, L>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab> Deserialize<'de> for Sum28<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab> where
    A: Deserialize<'de>,
    Aa: Deserialize<'de>,
    Ab: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum28<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I> Deserialize<'de> for Sum9<A, B, C, D, E, F, G, H, I> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum9<A, B, C, D, E, F, G, H, I>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A> Deserialize<'de> for Sum1<A> where
    A: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum1<A>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D> Deserialize<'de> for Sum4<A, B, C, D> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum4<A, B, C, D>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Deserialize<'de> for Sum20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad> Deserialize<'de> for Sum30<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad> where
    A: Deserialize<'de>,
    Aa: Deserialize<'de>,
    Ab: Deserialize<'de>,
    Ac: Deserialize<'de>,
    Ad: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum30<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J> Deserialize<'de> for Sum10<A, B, C, D, E, F, G, H, I, J> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum10<A, B, C, D, E, F, G, H, I, J>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> Deserialize<'de> for Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af> where
    A: Deserialize<'de>,
    Aa: Deserialize<'de>,
    Ab: Deserialize<'de>,
    Ac: Deserialize<'de>,
    Ad: Deserialize<'de>,
    Ae: Deserialize<'de>,
    Af: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum32<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac, Ad, Ae, Af>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac> Deserialize<'de> for Sum29<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac> where
    A: Deserialize<'de>,
    Aa: Deserialize<'de>,
    Ab: Deserialize<'de>,
    Ac: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>,
    Y: Deserialize<'de>,
    Z: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Sum29<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Aa, Ab, Ac>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, V> Deserialize<'de> for HyperLogLogMagnitude<V>

fn deserialize<__D>(
    __deserializer: __D
) -> Result<HyperLogLogMagnitude<V>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, T> Deserialize<'de> for SampleUnstable<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SampleUnstable<T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, K, C> Deserialize<'de> for CountMinSketch<K, C> where
    C: New + Deserialize<'de>,
    K: ?Sized,
    <C as New>::Config: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<CountMinSketch<K, C>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, V> Deserialize<'de> for HyperLogLog<V> where
    V: ?Sized, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<HyperLogLog<V>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de, A, C> Deserialize<'de> for Top<A, C> where
    A: Hash + Eq + Deserialize<'de>,
    C: New + Deserialize<'de>,
    <C as New>::Config: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Top<A, C>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for SampleTotal

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SampleTotal, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NaiveDateTime

fn deserialize<D>(
    deserializer: D
) -> Result<NaiveDateTime, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for DateTime<FixedOffset>

Deserialize a value that optionally includes a timezone offset in its string representation

The value to be deserialized must be an rfc3339 string.

See the serde module for alternate deserialization formats.

fn deserialize<D>(
    deserializer: D
) -> Result<DateTime<FixedOffset>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Weekday

fn deserialize<D>(
    deserializer: D
) -> Result<Weekday, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NaiveTime

fn deserialize<D>(
    deserializer: D
) -> Result<NaiveTime, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for NaiveDate

fn deserialize<D>(
    deserializer: D
) -> Result<NaiveDate, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for DateTime<Utc>

Deserialize into a UTC value

The value to be deserialized must be an rfc3339 string.

See the serde module for alternate deserialization formats.

fn deserialize<D>(
    deserializer: D
) -> Result<DateTime<Utc>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Tz

fn deserialize<D>(
    deserializer: D
) -> Result<Tz, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

Loading content...

Implementors

impl<'de> Deserialize<'de> for Decimal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for IpAddr

fn deserialize<D>(
    deserializer: D
) -> Result<IpAddr, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Value

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Bson

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Date

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for amadeus_types::DateTime

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for DateTimeWithoutTimezone

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for DateWithoutTimezone

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Enum

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Group

fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Json

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Time

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for TimeWithoutTimezone

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Timezone

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de> Deserialize<'de> for Url

Deserializes this URL from a serde stream.

This implementation is only available if the serde Cargo feature is enabled.

fn deserialize<D>(
    deserializer: D
) -> Result<Url, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<'de, 'a> Deserialize<'de> for Webpage<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

impl<'de, T: Data> Deserialize<'de> for List<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Loading content...