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, 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, 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> Deserialize<'de> for NonZeroI128

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI128, <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 Ipv6Addr

fn deserialize<D>(
    deserializer: D
) -> Result<Ipv6Addr, <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, 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, '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, 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> 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 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> Deserialize<'de> for u32

fn deserialize<D>(
    deserializer: D
) -> Result<u32, <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; 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, '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> Deserialize<'de> for AtomicBool

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicBool, <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, 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 AtomicI8

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI8, <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, 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, 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, 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, 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> Deserialize<'de> for bool

fn deserialize<D>(
    deserializer: D
) -> Result<bool, <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; 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, 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 AtomicIsize

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicIsize, <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> 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 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> Deserialize<'de> for AtomicU8

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicU8, <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 PathBuf

fn deserialize<D>(
    deserializer: D
) -> Result<PathBuf, <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 Box<CStr>

fn deserialize<D>(
    deserializer: D
) -> Result<Box<CStr>, <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, 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, 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> 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 NonZeroI64

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI64, <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, 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 AtomicI32

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI32, <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, 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, 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, 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, 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 NonZeroU128

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroU128, <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, 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> Deserialize<'de> for i32

fn deserialize<D>(
    deserializer: D
) -> Result<i32, <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, '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; 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 SocketAddr

fn deserialize<D>(
    deserializer: D
) -> Result<SocketAddr, <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> Deserialize<'de> for u8

fn deserialize<D>(
    deserializer: D
) -> Result<u8, <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> Deserialize<'de> for AtomicU64

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicU64, <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, 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 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, 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 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, 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, 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 NonZeroU32

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroU32, <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> Deserialize<'de> for f32

fn deserialize<D>(
    deserializer: D
) -> Result<f32, <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 AtomicI64

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI64, <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; 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, 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 i8

fn deserialize<D>(
    deserializer: D
) -> Result<i8, <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; 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, 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 [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> Deserialize<'de> for usize

fn deserialize<D>(
    deserializer: D
) -> Result<usize, <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> Deserialize<'de> for u64

fn deserialize<D>(
    deserializer: D
) -> Result<u64, <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> 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 NonZeroIsize

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroIsize, <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> Deserialize<'de> for AtomicUsize

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicUsize, <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, 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, '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, 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 NonZeroI32

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI32, <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 AtomicU32

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicU32, <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 [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 [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 NonZeroI16

fn deserialize<D>(
    deserializer: D
) -> Result<NonZeroI16, <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> Deserialize<'de> for Box<Path>

fn deserialize<D>(
    deserializer: D
) -> Result<Box<Path>, <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> Deserialize<'de> for AtomicI16

fn deserialize<D>(
    deserializer: D
) -> Result<AtomicI16, <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; 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, 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> 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 [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, 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; 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 u16

fn deserialize<D>(
    deserializer: D
) -> Result<u16, <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> Deserialize<'de> for IgnoredAny

fn deserialize<D>(
    deserializer: D
) -> Result<IgnoredAny, <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 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> 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 Ipv4Addr

fn deserialize<D>(
    deserializer: D
) -> Result<Ipv4Addr, <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; 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, 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, 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 SocketAddrV6

fn deserialize<D>(
    deserializer: D
) -> Result<SocketAddrV6, <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 OsString

fn deserialize<D>(
    deserializer: D
) -> Result<OsString, <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, 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, 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> 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, Item, F> Deserialize<'de> for AllReducerAsync<Item, F> where
    F: Deserialize<'de>, 

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

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

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ExtendReducer<Item, T>, <__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, 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, 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, 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, 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, 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> 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, 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> 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 Never

fn deserialize<D>(
    _deserializer: D
) -> Result<Never, <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, 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, 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, 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, Item, F> Deserialize<'de> for AnyReducer<Item, F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AnyReducer<Item, F>, <__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, 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, 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, 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> 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 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, 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 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 SampleUnstableFolder

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SampleUnstableFolder, <__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, 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, Item, F> Deserialize<'de> for AllReducer<Item, F> where
    F: Deserialize<'de>, 

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

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

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AnyReducerAsync<Item, F>, <__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> 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> Deserialize<'de> for Serde<ErrorKind>

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

impl<'de, Item, F> Deserialize<'de> for FolderSyncReducer<Item, F> where
    F: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FolderSyncReducer<Item, F>, <__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, 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, 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> Deserialize<'de> for BoolOrReducer

fn deserialize<__D>(
    __deserializer: __D
) -> Result<BoolOrReducer, <__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 BoolOrReducerAsync

fn deserialize<__D>(
    __deserializer: __D
) -> Result<BoolOrReducerAsync, <__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, 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, 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, Item, ID, F, B, Step> Deserialize<'de> for FoldFolder<Item, ID, F, B, Step> where
    F: Deserialize<'de>,
    ID: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<FoldFolder<Item, ID, F, B, Step>, <__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, 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, Item, T> Deserialize<'de> for PushReducer<Item, T>

fn deserialize<__D>(
    __deserializer: __D
) -> Result<PushReducer<Item, T>, <__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, 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> 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> Deserialize<'de> for ReduceC0

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

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

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ForEachReducer<Item, 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, 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> Deserialize<'de> for MostFrequentFolder

fn deserialize<__D>(
    __deserializer: __D
) -> Result<MostFrequentFolder, <__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, 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 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, 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, 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> 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, 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, 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, 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> 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, 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, 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> 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> 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, 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> 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> 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> 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, 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, 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> 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, 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, 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> 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, 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> 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> 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, 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> 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, 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, 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> 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> 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, 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, 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, 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> 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, K, V, S> Deserialize<'de> for IndexMap<K, V, S> where
    K: Deserialize<'de> + Eq + Hash,
    S: Default + BuildHasher,
    V: Deserialize<'de>, 

Requires crate feature "serde-1"

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

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

Requires crate feature "serde-1"

fn deserialize<D>(
    deserializer: D
) -> Result<IndexSet<T, S>, <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, 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, 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> Deserialize<'de> for SampleTotal

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SampleTotal, <__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> 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 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 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 NaiveDateTime

fn deserialize<D>(
    deserializer: D
) -> Result<NaiveDateTime, <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 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...