Trait concordium_rust_sdk::common::SerdeSerialize

pub trait SerdeSerialize {
    // Required method
    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()
    }
}

Object Safety

This trait is not object safe.

Implementations on Foreign Types

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 SocketAddr

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

where S: Serializer,

impl Serialize for Month

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

where S: Serializer,

impl Serialize for Weekday

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 bool

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 Serialize for f32

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 Serialize for i8

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 i32

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 i128

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 Serialize for str

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 Serialize for u16

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 u64

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 ()

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 Serialize for CString

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 Serialize for CStr

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 Serialize for Ipv6Addr

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 Serialize for SocketAddrV6

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

where S: Serializer,

impl Serialize for NonZero<i8>

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

where S: Serializer,

impl Serialize for NonZero<i16>

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

where S: Serializer,

impl Serialize for NonZero<i32>

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

where S: Serializer,

impl Serialize for NonZero<i64>

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

where S: Serializer,

impl Serialize for NonZero<i128>

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

where S: Serializer,

impl Serialize for NonZero<isize>

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

where S: Serializer,

impl Serialize for NonZero<u8>

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

where S: Serializer,

impl Serialize for NonZero<u16>

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

where S: Serializer,

impl Serialize for NonZero<u32>

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

where S: Serializer,

impl Serialize for NonZero<u64>

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

where S: Serializer,

impl Serialize for NonZero<u128>

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

where S: Serializer,

impl Serialize for NonZero<usize>

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 Serialize for AtomicI8

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 Serialize for AtomicI32

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 AtomicIsize

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 Serialize for AtomicU16

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 Serialize for AtomicU64

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 Serialize for Duration

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 Serialize for OsString

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 Serialize for PathBuf

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 NaiveDate

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

where S: Serializer,

impl Serialize for NaiveDateTime

Serialize a NaiveDateTime as an RFC 3339 string

See the serde module for alternate serialization formats.

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

where S: Serializer,

impl Serialize for NaiveTime

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

where S: Serializer,

impl Serialize for SigningKey

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

where __S: Serializer,

impl Serialize for VerificationKey

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

where __S: Serializer,

impl Serialize for VerificationKeyBytes

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 Decimal

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<'a> Serialize for Arguments<'a>

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<'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,

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,

impl<'a, T, U> Serialize for SerializeAsWrap<'a, T, U>

where U: SerializeAs<T> + ?Sized, T: ?Sized,

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

where S: Serializer,

impl<C1, C2> Serialize for Response<C1, C2>

where C1: Curve, C2: Curve<Scalar = <C1 as Curve>::Scalar>,

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

where GenericSerializerType: Serializer,

impl<C> Serialize for SetMembershipProof<C>

where C: Curve,

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

where GenericSerializerType: Serializer,

impl<C> Serialize for SetNonMembershipProof<C>

where C: Curve,

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

where GenericSerializerType: 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<Idx> Serialize for RangeFrom<Idx>

where Idx: Serialize,

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<Idx> Serialize for RangeTo<Idx>

where Idx: 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>

where K: Serialize, V: Serialize,

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, V: Serialize,

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

where S: Serializer,

impl<R> Serialize for SigmaProof<R>

where R: Serialize,

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

where GenericSerializerType: 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<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<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<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<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<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<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<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<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<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, 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<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<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<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<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<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<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<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<T> Serialize for [T; 0]

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<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<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; 5]

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; 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 [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; 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; 9]

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; 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; 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; 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; 14]

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<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<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 [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; 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; 20]

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; 21]

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<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<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<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<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<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<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<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<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<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<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<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<T> Serialize for Box<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 BinaryHeap<T>

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 BTreeSet<T>

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 LinkedList<T>

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 VecDeque<T>

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>

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 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 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<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<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<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<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<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 Response<T>

where T: Curve,

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

where GenericSerializerType: Serializer,

impl<T> Serialize for Response<T>

where T: Curve,

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

where GenericSerializerType: 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<T, H> Serialize for HashSet<T, H>

where T: Serialize,

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

where S: Serializer,

impl<Tz> Serialize for DateTime<Tz>

where Tz: TimeZone,

Serialize into an ISO 8601 formatted string.

See the serde module for alternate serializations.

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

where S: Serializer,

Implementors

impl Serialize for CredentialStatus

impl Serialize for concordium_rust_sdk::id::types::CredentialType

impl Serialize for SchemeId

impl Serialize for VerifyKey

impl Serialize for AccountStakingInfo

impl Serialize for DelegationTarget

impl Serialize for Level1Update

impl Serialize for OpenStatus

impl Serialize for PoolPendingChange

impl Serialize for PoolStatus

impl Serialize for ProtocolVersion

impl Serialize for RejectReason

impl Serialize for RewardsOverview

impl Serialize for RootUpdate

impl Serialize for SpecialTransactionOutcome

impl Serialize for StakePendingChange

impl Serialize for TransactionStatus

impl Serialize for TransactionStatusInBlock

impl Serialize for TransactionType

impl Serialize for UpdatePayload

impl Serialize for UpdateType

impl Serialize for PendingUpdateEffect

impl Serialize for concordium_rust_sdk::types::smart_contracts::concordium_contracts_common::Signature

impl Serialize for WasmVersion

impl Serialize for InstanceInfo

impl Serialize for Payload

impl Serialize for Network

impl Serialize for Web3IdAttribute

impl Serialize for EncryptionMethod

impl Serialize for KeyDerivationMethod

impl Serialize for Address

impl Serialize for TokenAmount

impl Serialize for TokenId

impl Serialize for CredentialEntry

impl Serialize for CredentialInfo

impl Serialize for concordium_rust_sdk::cis4::CredentialType

impl Serialize for MetadataUrl

impl Serialize for SchemaRef

impl Serialize for Ed25519DlogProof

impl Serialize for EncryptedAmountAggIndex

impl Serialize for EncryptedAmountIndex

impl Serialize for AttributeKind

impl Serialize for Threshold

impl Serialize for AccountKeys

impl Serialize for AccountOwnershipProof

impl Serialize for AccountOwnershipSignature

impl Serialize for ArIdentity

impl Serialize for AttributeStringTag

impl Serialize for AttributeTag

impl Serialize for ChoiceArParameters

impl Serialize for CredentialData

impl Serialize for CredentialPublicKeys

impl Serialize for Description

impl Serialize for InitialAccountData

impl Serialize for IpCdiSignature

impl Serialize for IpIdentity

impl Serialize for IpMetadata

impl Serialize for YearMonth

impl Serialize for NetworkId

impl Serialize for AccountNonceResponse

impl Serialize for BlockInfo

impl Serialize for Branch

impl Serialize for ConcordiumBFTDetails

impl Serialize for ConsensusInfo

impl Serialize for PendingUpdate

impl Serialize for AccountSignatures

impl Serialize for ChainMetadata

impl Serialize for CredentialSignatures

impl Serialize for concordium_rust_sdk::types::smart_contracts::concordium_contracts_common::Duration

The JSON serialization serialized the string obtained by using the Display implementation of the Duration.

impl Serialize for OwnedEntrypointName

impl Serialize for SignatureEcdsaSecp256k1

impl Serialize for SignatureEd25519

impl Serialize for ContractContext

impl Serialize for ContractEvent

impl Serialize for ModuleSource

impl Serialize for OwnedContractName

impl Serialize for OwnedParameter

impl Serialize for OwnedReceiveName

impl Serialize for ReturnValue

impl Serialize for WasmModule

impl Serialize for AbsoluteBlockHeight

impl Serialize for AccessStructure

impl Serialize for AccountEncryptedAmount

impl Serialize for AccountIndex

impl Serialize for AccountInfo

impl Serialize for AccountReleaseSchedule

impl Serialize for AmountFraction

impl Serialize for AuthorizationsV0

impl Serialize for AuthorizationsV1

impl Serialize for BakerAddedEvent

impl Serialize for BakerAggregationSignKey

impl Serialize for BakerAggregationVerifyKey

impl Serialize for BakerCredentials

impl Serialize for BakerElectionSignKey

impl Serialize for BakerElectionVerifyKey

impl Serialize for BakerId

impl Serialize for BakerInfo

impl Serialize for BakerKeyPairs

impl Serialize for BakerKeysEvent

impl Serialize for BakerParameters

impl Serialize for BakerPoolInfo

impl Serialize for BakerPoolStatus

impl Serialize for BakerSignatureSignKey

impl Serialize for BakerSignatureVerifyKey

impl Serialize for BirkBaker

impl Serialize for BirkParameters

impl Serialize for BlockHeight

impl Serialize for BlockItemSummary

impl Serialize for CapitalBound

impl Serialize for ChainParametersV0

impl Serialize for ChainParametersV1

impl Serialize for CommissionRanges

impl Serialize for CommissionRates

impl Serialize for CommonRewardData

impl Serialize for ContractAddress

impl Serialize for ContractInitializedEvent

impl Serialize for CooldownParameters

impl Serialize for CredentialRegistrationID

impl Serialize for CredentialsPerBlockLimit

impl Serialize for CurrentPaydayBakerPoolStatus

impl Serialize for DelegatorId

impl Serialize for DurationSeconds

impl Serialize for ElectionDifficulty

impl Serialize for EncryptedAmountRemovedEvent

impl Serialize for EncryptedSelfAmountAddedEvent

impl Serialize for Energy

impl Serialize for Epoch

impl Serialize for ExchangeRate

impl Serialize for FinalizationCommitteeParameters

impl Serialize for FinalizationIndex

impl Serialize for FinalizationSummary

impl Serialize for FinalizationSummaryParty

impl Serialize for GASRewards

impl Serialize for GASRewardsV1

impl Serialize for GenesisIndex

impl Serialize for InstanceUpdatedEvent

impl Serialize for LeverageFactor

impl Serialize for Memo

impl Serialize for MintDistributionV0

impl Serialize for MintDistributionV1

impl Serialize for MintRate

impl Serialize for NewEncryptedAmountEvent

impl Serialize for Nonce

impl Serialize for PartsPerHundredThousands

impl Serialize for PassiveDelegationStatus

impl Serialize for PendingUpdatesV0

impl Serialize for PendingUpdatesV1

impl Serialize for PoolParameters

impl Serialize for ProtocolUpdate

impl Serialize for RegisteredData

impl Serialize for Release

impl Serialize for RewardPeriodLength

impl Serialize for Round

impl Serialize for Slot

impl Serialize for SlotDuration

impl Serialize for TimeParameters

impl Serialize for TimeoutParameters

impl Serialize for TransactionFeeDistribution

impl Serialize for TransactionIndex

impl Serialize for UpdateKeyPair

impl Serialize for UpdateKeysIndex

impl Serialize for UpdateKeysThreshold

impl Serialize for UpdatePublicKey

impl Serialize for UpdateSequenceNumber

impl Serialize for UrlText

impl Serialize for PreAccountTransaction

impl Serialize for AddBakerPayload

impl Serialize for ConfigureBakerPayload

impl Serialize for ConfigureDelegationPayload

impl Serialize for EncodedPayload

impl Serialize for InitContractPayload

impl Serialize for PayloadSize

impl Serialize for TransactionHeader

impl Serialize for UpdateContractPayload

impl Serialize for Method

impl Serialize for LinkingProof

impl Serialize for CipherText

impl Serialize for EncryptedData

impl Serialize for EncryptionMetadata

impl Serialize for Version

impl Serialize for AccountAddress

impl Serialize for Amount

impl Serialize for CredentialIndex

impl Serialize for KeyIndex

impl Serialize for KeyPair

impl Serialize for Ratio

impl Serialize for concordium_rust_sdk::common::types::Signature

impl Serialize for Timestamp

The JSON serialization serialized the string obtained by using the Display implementation of the Timestamp.

impl Serialize for TransactionSignature

impl Serialize for TransactionTime

impl<'a> Serialize for EntrypointName<'a>

impl<Auths> Serialize for UpdateKeysCollectionSkeleton<Auths>

where Auths: Serialize,

impl<C> Serialize for AggregatedDecryptedAmount<C>

where C: Curve,

impl<C> Serialize for EncryptedAmount<C>

where C: Curve,

impl<C> Serialize for EncryptedAmountTransferData<C>

where C: Curve,

impl<C> Serialize for EncryptedAmountTransferProof<C>

where C: Curve,

impl<C> Serialize for IndexedEncryptedAmount<C>

where C: Curve,

impl<C> Serialize for SecToPubAmountTransferData<C>

where C: Curve,

impl<C> Serialize for SecToPubAmountTransferProof<C>

where C: Curve,

impl<C> Serialize for concordium_rust_sdk::id::curve_arithmetic::Value<C>

where C: Curve,

impl<C> Serialize for concordium_rust_sdk::id::dodis_yampolskiy_prf::SecretKey<C>

where C: Curve,

impl<C> Serialize for Cipher<C>

where C: Curve,

impl<C> Serialize for Message<C>

where C: Curve,

impl<C> Serialize for concordium_rust_sdk::id::elgamal::PublicKey<C>

where C: Curve,

impl<C> Serialize for concordium_rust_sdk::id::elgamal::SecretKey<C>

where C: Curve,

impl<C> Serialize for Commitment<C>

where C: Curve,

impl<C> Serialize for CommitmentKey<C>

where C: Curve,

impl<C> Serialize for Randomness<C>

where C: Curve,

impl<C> Serialize for VecCommitmentKey<C>

where C: Curve,

impl<C> Serialize for concordium_rust_sdk::id::ps_sig::PublicKey<C>

where C: Pairing,

impl<C> Serialize for Generators<C>

where C: Curve,

impl<C> Serialize for RangeProof<C>

where C: Curve,

impl<C> Serialize for AccCredentialInfo<C>

where C: Curve,

impl<C> Serialize for AnonymityRevocationRecord<C>

where C: Curve,

impl<C> Serialize for ArData<C>

where C: Curve,

impl<C> Serialize for ArInfo<C>

where C: Curve,

impl<C> Serialize for ArInfos<C>

where C: Curve,

impl<C> Serialize for ChainArData<C>

where C: Curve,

impl<C> Serialize for ChainArDecryptedData<C>

where C: Curve,

impl<C> Serialize for CommitmentsRandomness<C>

where C: Curve,

impl<C> Serialize for CredentialDeploymentCommitments<C>

where C: Curve,

impl<C> Serialize for CredentialHolderInfo<C>

where C: Curve,

impl<C> Serialize for GlobalContext<C>

where C: Curve,

impl<C> Serialize for IdCredentials<C>

where C: Curve,

impl<C> Serialize for IdRecoveryRequest<C>

where C: Curve,

impl<C> Serialize for IpAnonymityRevokers<C>

where C: Curve,

impl<C> Serialize for IpArData<C>

where C: Curve,

impl<C> Serialize for IpArDecryptedData<C>

where C: Curve,

impl<C> Serialize for PublicInformationForIp<C>

where C: Curve,

impl<C> Serialize for SignedCommitments<C>

where C: Curve,

impl<C, AttributeType> Serialize for AtomicProof<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for AccountCredentialValues<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for AccountCredentialWithoutProofs<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for CredentialProof<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for CredentialStatement<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for Proof<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for Statement<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for StatementWithContext<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for CredentialDeploymentValues<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for InitialCredentialDeploymentInfo<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for InitialCredentialDeploymentValues<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for Policy<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for Presentation<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for Request<C, AttributeType>

where C: Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, AttributeType> Serialize for Web3IdCredential<C, AttributeType>

where C: Curve, AttributeType: Clone + Serialize,

impl<C, TagType, AttributeType> Serialize for AtomicStatement<C, TagType, AttributeType>

where C: Curve, TagType: Serialize + Serialize, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, TagType, AttributeType> Serialize for AttributeInRangeStatement<C, TagType, AttributeType>

where C: Curve, TagType: Serialize + Serialize, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, TagType, AttributeType> Serialize for AttributeInSetStatement<C, TagType, AttributeType>

where C: Curve, TagType: Serialize + Serialize, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<C, TagType, AttributeType> Serialize for AttributeNotInSetStatement<C, TagType, AttributeType>

where C: Curve, TagType: Serialize + Serialize, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<F, AttributeType> Serialize for AttributeList<F, AttributeType>

where F: Field, AttributeType: Attribute<F> + Serialize,

impl<Kind> Serialize for NonZeroThresholdU8<Kind>

impl<Kind> Serialize for HigherLevelAccessStructure<Kind>

impl<MintDistribution, GasRewards> Serialize for RewardParametersSkeleton<MintDistribution, GasRewards>

where MintDistribution: Serialize, GasRewards: Serialize,

impl<P> Serialize for concordium_rust_sdk::aggregate_sig::PublicKey<P>

where P: Pairing,

impl<P> Serialize for IpData<P>

where P: Pairing,

impl<P> Serialize for IpInfo<P>

where P: Pairing,

impl<P> Serialize for IpInfos<P>

where P: Pairing,

impl<P, C> Serialize for CredDeploymentProofs<P, C>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField>,

impl<P, C> Serialize for IdObjectUseData<P, C>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve,

impl<P, C> Serialize for IdOwnershipProofs<P, C>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve,

impl<P, C> Serialize for PreIdentityObject<P, C>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve,

impl<P, C> Serialize for PreIdentityObjectV1<P, C>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve,

impl<P, C, AttributeType> Serialize for AccountCredential<P, C, AttributeType>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<P, C, AttributeType> Serialize for AccountCredentialMessage<P, C, AttributeType>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<P, C, AttributeType> Serialize for CredentialDeploymentInfo<P, C, AttributeType>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<P, C, AttributeType> Serialize for IdentityObject<P, C, AttributeType>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<P, C, AttributeType> Serialize for IdentityObjectV1<P, C, AttributeType>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<P, C, AttributeType> Serialize for UnsignedCredentialDeploymentInfo<P, C, AttributeType>

where P: Pairing, C: Curve<Scalar = <P as Pairing>::ScalarField, Scalar = <P as Pairing>::ScalarField> + Curve, AttributeType: Attribute<<C as Curve>::Scalar> + Serialize,

impl<PayloadType> Serialize for AccountTransaction<PayloadType>

where PayloadType: Serialize,

impl<Purpose> Serialize for HashBytes<Purpose>

impl<T> Serialize for InclusiveRange<T>

where T: Serialize,

impl<T> Serialize for ScheduledUpdate<T>

where T: Serialize,

impl<T> Serialize for UpdateQueue<T>

where T: Serialize,

impl<T> Serialize for Versioned<T>

where T: Serialize,

impl<TagType> Serialize for RevealAttributeStatement<TagType>

where TagType: Serialize + Serialize,

impl<UKC, CP, PU> Serialize for UpdatesSkeleton<UKC, CP, PU>

where UKC: Serialize, CP: Serialize, PU: Serialize,

impl<Upd> Serialize for BlockSummaryData<Upd>

where Upd: Serialize,

impl<V> Serialize for BakerKeysPayload<V>