Trait sp_runtime::Serialize

pub trait Serialize {
    fn serialize<S>(
        &self,
        serializer: S
    ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
    where
        S: Serializer;
}

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,

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

impl<T> Serialize for Compact<T>where
    T: Serialize,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

impl Serialize for AtomicIsize

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for usize

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for AtomicI16

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for isize

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

impl Serialize for str

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for AtomicI32

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for IpAddr

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for u32

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for AtomicI8

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for SystemTime

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Ipv6Addr

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for AtomicU32

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for u128

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<T> Serialize for RefCell<T>where
    T: Serialize + ?Sized,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for u64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for SocketAddrV6

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for i8

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for AtomicI64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for OsStr

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<T> Serialize for BTreeSet<T, Global>where
    T: Serialize + Ord,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for CString

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for NonZeroU16

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for NonZeroI64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for Ipv4Addr

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for NonZeroIsize

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for String

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

impl Serialize for NonZeroU32

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for NonZeroI16

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for AtomicU64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for NonZeroI8

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for CStr

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for AtomicU16

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for NonZeroUsize

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for f32

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<T> Serialize for [T; 0]

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

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,

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,

impl Serialize for OsString

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for u8

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for Duration

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl<'a, T> Serialize for &'a Twhere
    T: Serialize + ?Sized,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for ()

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

impl Serialize for u16

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a, T> Serialize for &'a mut Twhere
    T: Serialize + ?Sized,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for char

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for AtomicU8

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<T> Serialize for Mutex<T>where
    T: Serialize + ?Sized,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for i64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for AtomicUsize

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for i32

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for Path

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for NonZeroU128

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for f64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<T> Serialize for RwLock<T>where
    T: Serialize + ?Sized,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

impl Serialize for i16

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for i128

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for NonZeroI128

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for NonZeroU8

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for SocketAddrV4

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

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,

impl Serialize for NonZeroI32

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for PathBuf

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl Serialize for AtomicBool

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

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,

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,

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,

impl<K, V> Serialize for BTreeMap<K, V, Global>where
    K: Serialize + Ord,
    V: Serialize,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for SocketAddr

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for bool

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

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,

impl Serialize for NonZeroU64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

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,

impl<'a> Serialize for Arguments<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<T> Serialize for TypeDefTuple<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for UntrackedSymbol<T>

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for PortableRegistry

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for Field<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for Variant<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for Path<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeDefCompact<T>where
    T: Form,
    <T as Form>::Type: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeDefVariant<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeDefComposite<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for MetaForm

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeParameter<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for PortableForm

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for Interner<T>where
    T: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<'a, T> Serialize for Symbol<'a, T>

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for Type<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeDef<T>where
    T: Form,
    <T as Form>::Type: Serialize,
    <T as Form>::String: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeDefArray<T>where
    T: Form,
    <T as Form>::Type: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeDefBitSequence<T>where
    T: Form,
    <T as Form>::Type: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TypeDefPrimitive

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for TypeDefSequence<T>where
    T: Form,
    <T as Form>::Type: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Public

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Public

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Public

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for CryptoTypePublicPair

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Signature

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Public

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Bytes

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Public

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Signature

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for OpaquePeerId

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for OptLevel

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for ModuleTypes

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Tunables

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Initializer

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for MemoryInitialization

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for MemoryPlan

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for FunctionType

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TableInitializer

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for ModuleType

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for FunctionInfo

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TableInitialization

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for StackMap

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Module

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for MemoryInitializer

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for StackMapInformation

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for MemoryStyle

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Trampoline

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for FlagValue

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for AnyfuncIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for FilePos

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for StaticMemoryInitializer

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for InstructionAddressMap

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TablePlan

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TableStyle

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<K, V, S> Serialize for IndexMap<K, V, S>where
    K: Serialize + Hash + Eq,
    V: Serialize,
    S: BuildHasher,

Requires crate feature "serde" or "serde-1"

fn serialize<T>(
    &self,
    serializer: T
) -> Result<<T as Serializer>::Ok, <T as Serializer>::Error>where
    T: Serializer,

impl<T, S> Serialize for IndexSet<T, S>where
    T: Serialize + Hash + Eq,
    S: BuildHasher,

Requires crate feature "serde" or "serde-1"

fn serialize<Se>(
    &self,
    serializer: Se
) -> Result<<Se as Serializer>::Ok, <Se as Serializer>::Error>where
    Se: Serializer,

impl<K, V> Serialize for SecondaryMap<K, V>where
    K: EntityRef,
    V: Clone + PartialEq<V> + Serialize,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<K, V> Serialize for PrimaryMap<K, V>where
    K: EntityRef,
    V: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for PackedOption<T>where
    T: ReservedValue + Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for ListPool<T>where
    T: EntityRef + ReservedValue + Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<T> Serialize for EntityList<T>where
    T: EntityRef + ReservedValue,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<K, V> Serialize for SparseMap<K, V>where
    K: EntityRef + Serialize,
    V: SparseMapValue<K> + Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for ElemIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for EntityIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for DefinedGlobalIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for WasmFuncType

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for FuncIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Memory

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for GlobalIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for EntityType

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for DefinedFuncIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Tag

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TagIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for DefinedMemoryIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for WasmType

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for DefinedTableIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TypeIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for MemoryIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Table

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for TableIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for GlobalInit

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for DataIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for SignatureIndex

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Global

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Value

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Datetime

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<T> Serialize for Spanned<T>where
    T: Serialize,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Map<String, Value>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for CompiledModuleInfo

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for Value

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for RawValue

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Map<String, Value>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for Number

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for SerializeField

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeFieldMap<'a, Attributes<'_>>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeLevel<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeId<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeEvent<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeFieldMap<'a, Event<'_>>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeAttributes<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeFieldMap<'a, Record<'_>>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeFieldSet<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeMetadata<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl<'a> Serialize for SerializeRecord<'a>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for StorageKey

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for PrefixedStorageKey

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl<Hash> Serialize for StorageChangeSet<Hash>where
    Hash: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for StorageData

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for H128

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for H160

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for U128

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for U256

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for U512

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for H512

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for PublicKey

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

impl Serialize for VRFTranscriptValue

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

impl Serialize for FixedU64

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

Implementors

impl Serialize for ArithmeticError

impl Serialize for sp_runtime::DispatchError

impl Serialize for MultiSignature

impl Serialize for MultiSigner

impl Serialize for RuntimeString

impl Serialize for TokenError

impl Serialize for TransactionalError

impl Serialize for DigestItem

impl Serialize for Era

impl Serialize for sp_runtime::legacy::byte_sized_error::DispatchError

impl Serialize for StorageKind

impl Serialize for InvalidTransaction

impl Serialize for TransactionValidityError

impl Serialize for UnknownTransaction

impl Serialize for Digest

impl Serialize for sp_runtime::legacy::byte_sized_error::ModuleError

impl Serialize for sp_runtime::offchain::Duration

impl Serialize for Timestamp

impl Serialize for AccountId32

impl Serialize for AnySignature

impl Serialize for CryptoTypeId

impl Serialize for FixedI64

impl Serialize for FixedI128

impl Serialize for FixedU128

impl Serialize for Justifications

impl Serialize for KeyTypeId

impl Serialize for sp_runtime::ModuleError

impl Serialize for OpaqueExtrinsic

impl Serialize for PerU16

impl Serialize for Perbill

impl Serialize for Percent

impl Serialize for Permill

impl Serialize for Perquintill

impl Serialize for sp_runtime::testing::sr25519::Public

impl Serialize for sp_runtime::testing::sr25519::Signature

impl Serialize for H256

impl Serialize for TestSignature

impl Serialize for UintAuthorityId

impl Serialize for BlakeTwo256

impl Serialize for Keccak256

impl<Address: Encode, Signature: Encode, Call: Encode, Extra: SignedExtension> Serialize for UncheckedExtrinsic<Address, Call, Signature, Extra>

impl<Block> Serialize for BlockId<Block>where
    Block: Serialize + BlockT,
    Block::Hash: Serialize,

impl<Block> Serialize for SignedBlock<Block>where
    Block: Serialize,

impl<Call, Extra> Serialize for TestXt<Call, Extra>where
    TestXt<Call, Extra>: Encode,

impl<Header, Extrinsic> Serialize for sp_runtime::generic::Block<Header, Extrinsic>where
    Header: Serialize,
    Extrinsic: Serialize + MaybeSerialize,

impl<Number: Copy + Into<U256> + TryFrom<U256>, Hash: HashT> Serialize for Header<Number, Hash>where
    Hash::Output: Serialize,

impl<T, S> Serialize for BoundedVec<T, S>where
    T: Serialize,

impl<T, S> Serialize for WeakBoundedVec<T, S>where
    T: Serialize,

impl<Xt> Serialize for sp_runtime::testing::Block<Xt>where
    Xt: Serialize,

impl<Xt: Encode> Serialize for ExtrinsicWrapper<Xt>

impl Serialize for Extensions

impl Serialize for ExtensionsFork

impl Serialize for SessionKeys

impl Serialize for GenesisConfig

impl<T, U> Serialize for Cow<'_, T, U>where
    T: Beef + Serialize + ?Sized,
    U: Capacity,

impl Serialize for Public

impl Serialize for GenesisConfig

impl Serialize for GenesisConfig

impl Serialize for BenchmarkParameter

impl Serialize for BenchmarkBatch

impl Serialize for BenchmarkBatchSplitResults

impl Serialize for BenchmarkResult

impl Serialize for Requirements

impl Serialize for RuntimeMetadataV14

impl<T: Form> Serialize for ExtrinsicMetadata<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl<T: Form> Serialize for SignedExtensionMetadata<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl<T: Form> Serialize for PalletMetadata<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl<T: Form> Serialize for PalletStorageMetadata<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl<T: Form> Serialize for StorageEntryMetadata<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl Serialize for StorageEntryModifier

impl Serialize for StorageHasher

impl<T: Form> Serialize for StorageEntryType<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl<T: Form> Serialize for PalletCallMetadata<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl<T: Form> Serialize for PalletEventMetadata<T>where
    T::Type: Serialize,

impl<T: Form> Serialize for PalletConstantMetadata<T>where
    T::Type: Serialize,
    T::String: Serialize,

impl<T: Form> Serialize for PalletErrorMetadata<T>where
    T::Type: Serialize,

impl Serialize for RuntimeMetadataPrefixed

impl Serialize for RuntimeMetadata

impl Serialize for OpaqueMetadata

impl Serialize for RuntimeMetadataDeprecated

impl<T> Serialize for WrapperOpaque<T>where
    T: Serialize,

impl Serialize for Weight

impl Serialize for DispatchClass

impl Serialize for GenesisConfig

impl Serialize for Phase

impl<E, T> Serialize for EventRecord<E, T>where
    E: Serialize + Parameter + Member,
    T: Serialize,

impl Serialize for Ratio

impl<Balance> Serialize for Volume<Balance>where
    Balance: Serialize,

impl<Balance> Serialize for Liquidity<Balance>where
    Balance: Serialize,

impl<AccountId, AssetId, AssetPair, Balance> Serialize for AMMTransfer<AccountId, AssetId, AssetPair, Balance>where
    AccountId: Serialize,
    AssetId: Serialize,
    AssetPair: Serialize,
    Balance: Serialize,

impl Serialize for TwoPointZero

impl<'a> Serialize for ParamsSer<'a>

impl<'a> Serialize for SubscriptionId<'a>

impl<'a> Serialize for Id<'a>

impl<'a> Serialize for Request<'a>

impl<'a, T> Serialize for Notification<'a, T>where
    T: Serialize,

impl<'a> Serialize for RequestSer<'a>

impl<'a> Serialize for NotificationSer<'a>

impl<'a, T> Serialize for Response<'a, T>where
    T: Serialize,

impl<'a, T> Serialize for SubscriptionPayload<'a, T>where
    T: Serialize,

impl<'a, T> Serialize for SubscriptionPayloadError<'a, T>where
    T: Serialize,

impl<'a> Serialize for ErrorResponse<'a>

impl<'a> Serialize for ErrorObject<'a>

impl Serialize for ErrorCode

impl Serialize for SessionKeys

impl Serialize for GenesisConfig

impl Serialize for Multiaddr

impl<T: Config> Serialize for GenesisConfig<T>

impl<Value, Moment> Serialize for TimestampedValue<Value, Moment>where
    Value: Serialize + Ord + PartialOrd,
    Moment: Serialize,

impl<T: Config> Serialize for GenesisConfig<T>

impl<AssetId> Serialize for AssetType<AssetId>where
    AssetId: Serialize,

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config> Serialize for GenesisConfig<T>

impl Serialize for GenesisConfig

impl Serialize for GenesisConfig

impl<T: Config<I>, I: 'static> Serialize for GenesisConfig<T, I>

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config<I>, I: 'static> Serialize for GenesisConfig<T, I>

impl Serialize for VoteThreshold

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config> Serialize for GenesisConfig<T>

impl<BlockNumber> Serialize for OracleEntry<BlockNumber>where
    BlockNumber: Serialize,

impl Serialize for GenesisConfig

impl Serialize for GenesisConfig

impl Serialize for GenesisConfig

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config> Serialize for GenesisConfig<T>

impl Serialize for WeightCurveType

impl<AccountId, BlockNumber> Serialize for Pool<AccountId, BlockNumber>where
    AccountId: Serialize,
    BlockNumber: Serialize + AtLeast32BitUnsigned + Copy,

impl Serialize for GenesisConfig

impl<AccountId, Balance, BlockNumber> Serialize for Offer<AccountId, Balance, BlockNumber>where
    AccountId: Serialize,
    Balance: Serialize,
    BlockNumber: Serialize,

impl<AccountId> Serialize for Royalty<AccountId>where
    AccountId: Serialize,

impl<T: Config<I>, I: 'static> Serialize for GenesisConfig<T, I>

impl<BlockHash> Serialize for LeafProof<BlockHash>where
    BlockHash: Serialize,

impl<BlockHash> Serialize for LeafBatchProof<BlockHash>where
    BlockHash: Serialize,

impl<CollectionType, BoundedVec> Serialize for CollectionInfo<CollectionType, BoundedVec>where
    CollectionType: Serialize,
    BoundedVec: Serialize,

impl<BoundedVec> Serialize for ItemInfo<BoundedVec>where
    BoundedVec: Serialize,

impl Serialize for CollectionType

impl Serialize for NftPermissions

impl<T: Config> Serialize for GenesisConfig<T>

impl Serialize for PriceEntry

impl Serialize for PriceInfo

impl Serialize for BucketQueue

impl Serialize for GenesisConfig

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config<I>, I: 'static> Serialize for GenesisConfig<T, I>

impl<T: Config> Serialize for GenesisConfig<T>

impl<AccountId> Serialize for StakerStatus<AccountId>where
    AccountId: Serialize,

impl Serialize for Forcing

impl<T: Config> Serialize for GenesisConfig<T>

impl<T: Config> Serialize for GenesisConfig<T>

impl<Balance> Serialize for InclusionFee<Balance>where
    Balance: Serialize,

impl<Balance> Serialize for FeeDetails<Balance>where
    Balance: Serialize,

impl<Balance> Serialize for RuntimeDispatchInfo<Balance>where
    Balance: Display,

impl Serialize for GenesisConfig

impl<AccountId, Balance> Serialize for Proposal<AccountId, Balance>where
    AccountId: Serialize,
    Balance: Serialize,

impl Serialize for GenesisConfig

impl<T: Config> Serialize for GenesisConfig<T>

impl Serialize for GenesisConfig

impl Serialize for GenesisConfig

impl Serialize for GenesisConfig

impl Serialize for GenesisConfig

impl Serialize for Proof

impl Serialize for ErasureChunk

impl Serialize for HeadData

impl Serialize for ValidationCode

impl Serialize for BlockData

impl Serialize for Id

impl Serialize for ValidatorIndex

impl Serialize for SessionKeys

impl Serialize for GenesisConfig

impl Serialize for StatementKind

impl Serialize for EthereumAddress

impl<T: Config> Serialize for GenesisConfig<T>

impl Serialize for GenesisConfig

impl<BlockNumber> Serialize for HostConfiguration<BlockNumber>where
    BlockNumber: Serialize,

impl<T: Config> Serialize for GenesisConfig<T>

impl Serialize for GenesisConfig

impl Serialize for ParaGenesisArgs

impl Serialize for GenesisConfig

impl Serialize for Extensions

impl Serialize for AssetPair

impl Serialize for IntentionType

impl<AccountId, Balance, IntentionID> Serialize for ExchangeIntention<AccountId, Balance, IntentionID>where
    AccountId: Serialize,
    Balance: Serialize,
    IntentionID: Serialize,

impl Serialize for SessionKeys

impl Serialize for GenesisConfig

impl<BlockNumber, T> Serialize for Forks<BlockNumber, T>where
    BlockNumber: Serialize + Ord,
    T: Serialize + Group,

impl Serialize for ChainType

impl Serialize for ImportedAux

impl Serialize for EpochAuthorship

impl Serialize for NetworkState

impl Serialize for Peer

impl Serialize for NotConnectedPeer

impl Serialize for PeerEndpoint

impl Serialize for Endpoint

impl Serialize for MultiaddrWithPeerId

impl<Hash> Serialize for ExtrinsicOrHash<Hash>where
    Hash: Serialize,

impl Serialize for BlockStats

impl<Hash> Serialize for ReadProof<Hash>where
    Hash: Serialize,

impl Serialize for Health

impl<Hash, Number> Serialize for PeerInfo<Hash, Number>where
    Hash: Serialize,
    Number: Serialize,

impl Serialize for NodeRole

impl<Number> Serialize for SyncState<Number>where
    Number: Serialize,

impl<Block: BlockT> Serialize for LightSyncState<Block>

impl Serialize for HwBench

impl Serialize for TelemetryEndpoints

impl Serialize for ConnectionMessage

impl Serialize for SysInfo

impl Serialize for Values

impl<Hash, BlockHash> Serialize for TransactionStatus<Hash, BlockHash>where
    Hash: Serialize,
    BlockHash: Serialize,

impl Serialize for AllowedSlots

impl Serialize for BabeEpochConfiguration

impl Serialize for Slot

impl<N> Serialize for ScheduledChange<N>where
    N: Serialize,

impl<N> Serialize for ConsensusLog<N>where
    N: Serialize + Codec,

impl Serialize for OpaqueLeaf

impl Serialize for ElectionScore

impl<AccountId> Serialize for Support<AccountId>where
    AccountId: Serialize,

impl<T> Serialize for ListOrValue<T>where
    T: Serialize,

impl Serialize for NumberOrHex

impl Serialize for BlockTrace

impl Serialize for Event

impl Serialize for Span

impl Serialize for Data

impl Serialize for TraceError

impl Serialize for TraceBlockResponse

impl Serialize for RuntimeVersion

impl Serialize for MigrationStatusResult

impl Serialize for SessionKeys

impl Serialize for GenesisConfig

impl Serialize for SessionKeys

impl Serialize for GenesisConfig