pub trait Serialize {
    fn serialize<S>(
        &self, 
        serializer: S
    ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
    where
        S: Serializer;
}Expand description
A data structure that can be serialized into any data format supported by Serde.
Serde provides Serialize implementations for many Rust primitive and
standard library types. The complete list is here. All of these can
be serialized using Serde out of the box.
Additionally, Serde provides a procedural macro called serde_derive to
automatically generate Serialize 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 Serialize manually for some
type in your program. See the Implementing Serialize section of the
manual for more about this.
Third-party crates may provide Serialize implementations for types that
they expose. For example the linked-hash-map crate provides a
LinkedHashMap<K, V> type that is serializable by Serde because the crate
provides an implementation of Serialize for it.
Required Methods
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
Serialize this value into the given Serde serializer.
See the Implementing Serialize section of the manual for more
information about how to implement this method.
use serde::ser::{Serialize, SerializeStruct, Serializer};
struct Person {
    name: String,
    age: u8,
    phones: Vec<String>,
}
// This is what #[derive(Serialize)] would generate.
impl Serialize for Person {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("Person", 3)?;
        s.serialize_field("name", &self.name)?;
        s.serialize_field("age", &self.age)?;
        s.serialize_field("phones", &self.phones)?;
        s.end()
    }
}Implementations on Foreign Types
sourceimpl<T0> Serialize for (T0,) where
    T0: Serialize, 
 
impl<T0> Serialize for (T0,) where
    T0: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for Path
 
impl Serialize for Path
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for f32
 
impl Serialize for f32
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 27] where
    T: Serialize, 
 
impl<T> Serialize for [T; 27] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T] where
    T: Serialize, 
 
impl<T> Serialize for [T] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicU16
 
impl Serialize for AtomicU16
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for BinaryHeap<T> where
    T: Serialize + Ord, 
 
impl<T> Serialize for BinaryHeap<T> where
    T: Serialize + Ord, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 15] where
    T: Serialize, 
 
impl<T> Serialize for [T; 15] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicI64
 
impl Serialize for AtomicI64
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for SocketAddrV6
 
impl Serialize for SocketAddrV6
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for RwLock<T> where
    T: Serialize, 
 
impl<T> Serialize for RwLock<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 0]
 
impl<T> Serialize for [T; 0]
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 14] where
    T: Serialize, 
 
impl<T> Serialize for [T; 14] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for i128
 
impl Serialize for i128
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for CString
 
impl Serialize for CString
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicBool
 
impl Serialize for AtomicBool
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 2] where
    T: Serialize, 
 
impl<T> Serialize for [T; 2] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicU64
 
impl Serialize for AtomicU64
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicU8
 
impl Serialize for AtomicU8
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 6] where
    T: Serialize, 
 
impl<T> Serialize for [T; 6] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 21] where
    T: Serialize, 
 
impl<T> Serialize for [T; 21] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize,
    T13: Serialize,
    T14: Serialize,
    T15: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize,
    T13: Serialize,
    T14: Serialize,
    T15: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroI16
 
impl Serialize for NonZeroI16
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for i8
 
impl Serialize for i8
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for u32
 
impl Serialize for u32
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 9] where
    T: Serialize, 
 
impl<T> Serialize for [T; 9] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 19] where
    T: Serialize, 
 
impl<T> Serialize for [T; 19] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for i64
 
impl Serialize for i64
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 23] where
    T: Serialize, 
 
impl<T> Serialize for [T; 23] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 7] where
    T: Serialize, 
 
impl<T> Serialize for [T; 7] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Option<T> where
    T: Serialize, 
 
impl<T> Serialize for Option<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for SystemTime
 
impl Serialize for SystemTime
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 18] where
    T: Serialize, 
 
impl<T> Serialize for [T; 18] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Vec<T, Global> where
    T: Serialize, 
 
impl<T> Serialize for Vec<T, Global> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicI8
 
impl Serialize for AtomicI8
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for str
 
impl Serialize for str
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for IpAddr
 
impl Serialize for IpAddr
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroU32
 
impl Serialize for NonZeroU32
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for PathBuf
 
impl Serialize for PathBuf
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 1] where
    T: Serialize, 
 
impl<T> Serialize for [T; 1] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for Ipv4Addr
 
impl Serialize for Ipv4Addr
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<Idx> Serialize for RangeInclusive<Idx> where
    Idx: Serialize, 
 
impl<Idx> Serialize for RangeInclusive<Idx> where
    Idx: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 13] where
    T: Serialize, 
 
impl<T> Serialize for [T; 13] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for u128
 
impl Serialize for u128
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4> Serialize for (T0, T1, T2, T3, T4) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize, 
 
impl<T0, T1, T2, T3, T4> Serialize for (T0, T1, T2, T3, T4) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 26] where
    T: Serialize, 
 
impl<T> Serialize for [T; 26] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 16] where
    T: Serialize, 
 
impl<T> Serialize for [T; 16] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for CStr
 
impl Serialize for CStr
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 25] where
    T: Serialize, 
 
impl<T> Serialize for [T; 25] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicU32
 
impl Serialize for AtomicU32
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 4] where
    T: Serialize, 
 
impl<T> Serialize for [T; 4] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 20] where
    T: Serialize, 
 
impl<T> Serialize for [T; 20] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize,
    T13: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize,
    T13: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for VecDeque<T, Global> where
    T: Serialize, 
 
impl<T> Serialize for VecDeque<T, Global> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for Duration
 
impl Serialize for Duration
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for u16
 
impl Serialize for u16
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicIsize
 
impl Serialize for AtomicIsize
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroI64
 
impl Serialize for NonZeroI64
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<K, V, H> Serialize for HashMap<K, V, H> where
    K: Serialize + Eq + Hash,
    V: Serialize,
    H: BuildHasher, 
 
impl<K, V, H> Serialize for HashMap<K, V, H> where
    K: Serialize + Eq + Hash,
    V: Serialize,
    H: BuildHasher, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for RefCell<T> where
    T: Serialize, 
 
impl<T> Serialize for RefCell<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicI16
 
impl Serialize for AtomicI16
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for String
 
impl Serialize for String
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize, 
 
impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroUsize
 
impl Serialize for NonZeroUsize
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 3] where
    T: Serialize, 
 
impl<T> Serialize for [T; 3] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 24] where
    T: Serialize, 
 
impl<T> Serialize for [T; 24] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroU8
 
impl Serialize for NonZeroU8
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for u8
 
impl Serialize for u8
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2> Serialize for (T0, T1, T2) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize, 
 
impl<T0, T1, T2> Serialize for (T0, T1, T2) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for isize
 
impl Serialize for isize
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 28] where
    T: Serialize, 
 
impl<T> Serialize for [T; 28] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<'a> Serialize for Arguments<'a>
 
impl<'a> Serialize for Arguments<'a>
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T, E> Serialize for Result<T, E> where
    T: Serialize,
    E: Serialize, 
 
impl<T, E> Serialize for Result<T, E> where
    T: Serialize,
    E: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for char
 
impl Serialize for char
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 30] where
    T: Serialize, 
 
impl<T> Serialize for [T; 30] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<Idx> Serialize for Range<Idx> where
    Idx: Serialize, 
 
impl<Idx> Serialize for Range<Idx> where
    Idx: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for i32
 
impl Serialize for i32
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicI32
 
impl Serialize for AtomicI32
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Bound<T> where
    T: Serialize, 
 
impl<T> Serialize for Bound<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Box<T, Global> where
    T: Serialize + ?Sized, 
 
impl<T> Serialize for Box<T, Global> where
    T: Serialize + ?Sized, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 17] where
    T: Serialize, 
 
impl<T> Serialize for [T; 17] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<'a, T> Serialize for &'a mut T where
    T: Serialize + ?Sized, 
 
impl<'a, T> Serialize for &'a mut T where
    T: Serialize + ?Sized, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for BTreeSet<T> where
    T: Serialize + Ord, 
 
impl<T> Serialize for BTreeSet<T> where
    T: Serialize + Ord, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for u64
 
impl Serialize for u64
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 5] where
    T: Serialize, 
 
impl<T> Serialize for [T; 5] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for i16
 
impl Serialize for i16
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for AtomicUsize
 
impl Serialize for AtomicUsize
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 12] where
    T: Serialize, 
 
impl<T> Serialize for [T; 12] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 22] where
    T: Serialize, 
 
impl<T> Serialize for [T; 22] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroU128
 
impl Serialize for NonZeroU128
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Mutex<T> where
    T: Serialize, 
 
impl<T> Serialize for Mutex<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1> Serialize for (T0, T1) where
    T0: Serialize,
    T1: Serialize, 
 
impl<T0, T1> Serialize for (T0, T1) where
    T0: Serialize,
    T1: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for PhantomData<T> where
    T: ?Sized, 
 
impl<T> Serialize for PhantomData<T> where
    T: ?Sized, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for usize
 
impl Serialize for usize
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 29] where
    T: Serialize, 
 
impl<T> Serialize for [T; 29] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for SocketAddrV4
 
impl Serialize for SocketAddrV4
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroU16
 
impl Serialize for NonZeroU16
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Cell<T> where
    T: Serialize + Copy, 
 
impl<T> Serialize for Cell<T> where
    T: Serialize + Copy, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for OsString
 
impl Serialize for OsString
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroU64
 
impl Serialize for NonZeroU64
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for bool
 
impl Serialize for bool
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroI32
 
impl Serialize for NonZeroI32
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<'a, T> Serialize for Cow<'a, T> where
    T: Serialize + ToOwned + ?Sized, 
 
impl<'a, T> Serialize for Cow<'a, T> where
    T: Serialize + ToOwned + ?Sized, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize,
    T13: Serialize,
    T14: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize,
    T8: Serialize,
    T9: Serialize,
    T10: Serialize,
    T11: Serialize,
    T12: Serialize,
    T13: Serialize,
    T14: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for OsStr
 
impl Serialize for OsStr
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for LinkedList<T> where
    T: Serialize, 
 
impl<T> Serialize for LinkedList<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5> Serialize for (T0, T1, T2, T3, T4, T5) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5> Serialize for (T0, T1, T2, T3, T4, T5) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 10] where
    T: Serialize, 
 
impl<T> Serialize for [T; 10] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6, T7> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize,
    T7: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroI8
 
impl Serialize for NonZeroI8
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 11] where
    T: Serialize, 
 
impl<T> Serialize for [T; 11] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<'a, T> Serialize for &'a T where
    T: Serialize + ?Sized, 
 
impl<'a, T> Serialize for &'a T where
    T: Serialize + ?Sized, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for ()
 
impl Serialize for ()
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for SocketAddr
 
impl Serialize for SocketAddr
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 8] where
    T: Serialize, 
 
impl<T> Serialize for [T; 8] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T0, T1, T2, T3, T4, T5, T6> Serialize for (T0, T1, T2, T3, T4, T5, T6) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize, 
 
impl<T0, T1, T2, T3, T4, T5, T6> Serialize for (T0, T1, T2, T3, T4, T5, T6) where
    T0: Serialize,
    T1: Serialize,
    T2: Serialize,
    T3: Serialize,
    T4: Serialize,
    T5: Serialize,
    T6: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T, H> Serialize for HashSet<T, H> where
    T: Serialize + Eq + Hash,
    H: BuildHasher, 
 
impl<T, H> Serialize for HashSet<T, H> where
    T: Serialize + Eq + Hash,
    H: BuildHasher, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroI128
 
impl Serialize for NonZeroI128
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for f64
 
impl Serialize for f64
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<K, V> Serialize for BTreeMap<K, V> where
    K: Serialize + Ord,
    V: Serialize, 
 
impl<K, V> Serialize for BTreeMap<K, V> where
    K: Serialize + Ord,
    V: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Wrapping<T> where
    T: Serialize, 
 
impl<T> Serialize for Wrapping<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for Reverse<T> where
    T: Serialize, 
 
impl<T> Serialize for Reverse<T> where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for NonZeroIsize
 
impl Serialize for NonZeroIsize
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for Ipv6Addr
 
impl Serialize for Ipv6Addr
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 32] where
    T: Serialize, 
 
impl<T> Serialize for [T; 32] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<T> Serialize for [T; 31] where
    T: Serialize, 
 
impl<T> Serialize for [T; 31] where
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl<Ser, T> Serialize for Base64Of<Ser, T> where
    Ser: Serde,
    T: Serialize, 
 
impl<Ser, T> Serialize for Base64Of<Ser, T> where
    Ser: Serde,
    T: Serialize, 
fn serialize<S>(
    &self, 
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 
sourceimpl Serialize for Tx
 
impl Serialize for Tx
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for BurnFromAction
 
impl Serialize for BurnFromAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TokenInfo
 
impl Serialize for TokenInfo
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for SendFromAction
 
impl Serialize for SendFromAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for QueryMsg
 
impl Serialize for QueryMsg
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TxAction
 
impl Serialize for TxAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Minters
 
impl Serialize for Minters
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ContractStatusLevel
 
impl Serialize for ContractStatusLevel
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TransferAction
 
impl Serialize for TransferAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TransactionHistory
 
impl Serialize for TransactionHistory
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TransferFromAction
 
impl Serialize for TransferFromAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for RichTx
 
impl Serialize for RichTx
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Allowance
 
impl Serialize for Allowance
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for HandleMsg
 
impl Serialize for HandleMsg
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Balance
 
impl Serialize for Balance
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TokenConfig
 
impl Serialize for TokenConfig
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ContractStatus
 
impl Serialize for ContractStatus
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TransferHistory
 
impl Serialize for TransferHistory
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for SendAction
 
impl Serialize for SendAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ExchangeRate
 
impl Serialize for ExchangeRate
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for MintAction
 
impl Serialize for MintAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl<T> Serialize for FeatureToggleQueryMsg<T> where
    T: Serialize + DeserializeOwned, 
 
impl<T> Serialize for FeatureToggleQueryMsg<T> where
    T: Serialize + DeserializeOwned, 
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Contract
 
impl Serialize for Contract
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl<T> Serialize for FeatureToggleHandleMsg<T> where
    T: Serialize + DeserializeOwned, 
 
impl<T> Serialize for FeatureToggleHandleMsg<T> where
    T: Serialize + DeserializeOwned, 
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Status
 
impl Serialize for Status
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl<T> Serialize for FeatureStatus<T> where
    T: Serialize, 
 
impl<T> Serialize for FeatureStatus<T> where
    T: Serialize, 
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ApprovedForAll
 
impl Serialize for ApprovedForAll
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for AllNftInfo
 
impl Serialize for AllNftInfo
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for OwnerOfResponse
 
impl Serialize for OwnerOfResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for AccessLevel
 
impl Serialize for AccessLevel
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for OwnerOf
 
impl Serialize for OwnerOf
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ContractInfoResponse
 
impl Serialize for ContractInfoResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TokenApprovals
 
impl Serialize for TokenApprovals
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for VerifyTransferApproval
 
impl Serialize for VerifyTransferApproval
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for NftInfoResponse
 
impl Serialize for NftInfoResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for AllNftInfoResponse
 
impl Serialize for AllNftInfoResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Minters
 
impl Serialize for Minters
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TokenApprovalsResponse
 
impl Serialize for TokenApprovalsResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ViewerInfo
 
impl Serialize for ViewerInfo
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ContractInfo
 
impl Serialize for ContractInfo
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Transfer
 
impl Serialize for Transfer
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Mint
 
impl Serialize for Mint
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for VerifyTransferApprovalResponse
 
impl Serialize for VerifyTransferApprovalResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for MintersResponse
 
impl Serialize for MintersResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Expiration
 
impl Serialize for Expiration
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for IsUnwrappedResponse
 
impl Serialize for IsUnwrappedResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Tx
 
impl Serialize for Tx
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Metadata
 
impl Serialize for Metadata
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for NumTokens
 
impl Serialize for NumTokens
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TokenList
 
impl Serialize for TokenList
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for PrivateMetadataResponse
 
impl Serialize for PrivateMetadataResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for NftDossier
 
impl Serialize for NftDossier
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TxAction
 
impl Serialize for TxAction
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for MediaFile
 
impl Serialize for MediaFile
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for InventoryApprovals
 
impl Serialize for InventoryApprovals
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for NumTokensResponse
 
impl Serialize for NumTokensResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for NftDossierResponse
 
impl Serialize for NftDossierResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for QueryMsg
 
impl Serialize for QueryMsg
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for IsUnwrapped
 
impl Serialize for IsUnwrapped
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Burn
 
impl Serialize for Burn
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Trait
 
impl Serialize for Trait
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TransactionHistory
 
impl Serialize for TransactionHistory
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for InventoryApprovalsResponse
 
impl Serialize for InventoryApprovalsResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Cw721Approval
 
impl Serialize for Cw721Approval
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TokenListResponse
 
impl Serialize for TokenListResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Send
 
impl Serialize for Send
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Extension
 
impl Serialize for Extension
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for ApprovedForAllResponse
 
impl Serialize for ApprovedForAllResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Authentication
 
impl Serialize for Authentication
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for HandleMsg
 
impl Serialize for HandleMsg
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for TransactionHistoryResponse
 
impl Serialize for TransactionHistoryResponse
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
sourceimpl Serialize for Snip721Approval
 
impl Serialize for Snip721Approval
fn serialize<__S>(
    &self, 
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 
Implementors
impl Serialize for fadroma::admin::HandleMsg
impl Serialize for fadroma::admin::QueryMsg
impl Serialize for fadroma::killswitch::ContractStatusLevel
impl Serialize for fadroma::killswitch::HandleMsg
impl Serialize for fadroma::killswitch::QueryMsg
impl Serialize for fadroma::snip20_impl::msg::ContractStatusLevel
impl Serialize for HandleAnswer
impl Serialize for fadroma::snip20_impl::msg::HandleMsg
impl Serialize for QueryAnswer
impl Serialize for fadroma::snip20_impl::msg::QueryMsg
impl Serialize for QueryPermission
impl Serialize for QueryWithPermit
impl Serialize for ResponseStatus
impl Serialize for fadroma::snip20_impl::transaction_history::TxAction
impl Serialize for AuthHandleAnswer
impl Serialize for AuthResponseStatus
impl Serialize for fadroma::vk::vk_auth::HandleMsg
impl Serialize for fadroma::vk::vk_auth::QueryMsg
impl Serialize for BankMsg
impl Serialize for BankQuery
impl Serialize for DistQuery
impl Serialize for GovMsg
impl Serialize for GovQuery
impl Serialize for MintQuery
impl Serialize for StakingMsg
impl Serialize for StakingQuery
impl Serialize for StdError
impl Serialize for SystemError
impl Serialize for VoteOption
impl Serialize for WasmMsg
impl Serialize for WasmQuery
impl Serialize for Value
impl Serialize for InstanceType
impl Serialize for Schema
impl Serialize for fadroma::admin::InitMsg
impl Serialize for ContractInstantiationInfo
impl Serialize for MockEnv
impl Serialize for Decimal256
Serializes as a decimal string
impl Serialize for Uint256
impl Serialize for fadroma::permit::Coin
impl Serialize for Fee
impl Serialize for PermitSignature
impl Serialize for PubKey
impl Serialize for fadroma::snip20_impl::batch::BurnFromAction
impl Serialize for fadroma::snip20_impl::batch::MintAction
impl Serialize for fadroma::snip20_impl::batch::SendAction
impl Serialize for fadroma::snip20_impl::batch::SendFromAction
impl Serialize for fadroma::snip20_impl::batch::TransferAction
impl Serialize for fadroma::snip20_impl::batch::TransferFromAction
impl Serialize for CreateViewingKeyResponse
impl Serialize for InitConfig
impl Serialize for fadroma::snip20_impl::msg::InitMsg
impl Serialize for InitialAllowance
impl Serialize for InitialBalance
impl Serialize for Snip20ReceiveMsg
impl Serialize for fadroma::snip20_impl::state::Allowance
impl Serialize for Constants
impl Serialize for fadroma::snip20_impl::transaction_history::RichTx
impl Serialize for fadroma::snip20_impl::transaction_history::Tx
impl Serialize for ViewingKey
impl Serialize for Map<String, Value>
impl Serialize for Number
impl Serialize for ArrayValidation
impl Serialize for fadroma::prelude::schemars::schema::Metadata
impl Serialize for NumberValidation
impl Serialize for ObjectValidation
impl Serialize for RootSchema
impl Serialize for SchemaObject
impl Serialize for StringValidation
impl Serialize for SubschemaValidation
impl Serialize for AllBalanceResponse
impl Serialize for AllDelegationsResponse
impl Serialize for BalanceResponse
impl Serialize for Binary
Serializes as a base64 string
impl Serialize for BlockInfo
impl Serialize for BondedDenomResponse
impl Serialize for BondedRatioResponse
impl Serialize for CanonicalAddr
impl Serialize for fadroma::prelude::Coin
impl Serialize for fadroma::prelude::ContractInfo
impl Serialize for Decimal
Serializes as a decimal string
impl Serialize for Delegation
impl Serialize for Empty
impl Serialize for Env
impl Serialize for FullDelegation
impl Serialize for HumanAddr
impl Serialize for InflationResponse
impl Serialize for LogAttribute
impl Serialize for MessageInfo
impl Serialize for ProposalsResponse
impl Serialize for RewardsResponse
impl Serialize for Uint128
Serializes as a base64 string