Trait frame_support::pallet_prelude::TypeInfo

pub trait TypeInfo {
    type Identity: 'static + ?Sized;
    fn type_info() -> Type<MetaForm>;
}

Implementors return their meta type information.

Associated Types

type Identity: 'static + ?Sized

The type identifying for which type info is provided.

Note

This is used to uniquely identify a type via core::any::TypeId::of. In most cases it will just be Self, but can be used to unify different types which have the same encoded representation e.g. reference types Box<T>, &T and &mut T.

Required methods

fn type_info() -> Type<MetaForm>

Returns the static type identifier for Self.

Implementations on Foreign Types

impl TypeInfo for i64

type Identity = i64

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo,
    N: 'static + TypeInfo,
    O: 'static + TypeInfo,
    P: 'static + TypeInfo,
    Q: 'static + TypeInfo,
    R: 'static + TypeInfo,
    S: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo,
    N: 'static + TypeInfo,
    O: 'static + TypeInfo,
    P: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for u8

type Identity = u8

pub fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Option<T> where
    T: 'static + TypeInfo, 

type Identity = Option<T>

pub fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for [T] where
    T: 'static + TypeInfo, 

type Identity = [T]

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo,
    N: 'static + TypeInfo,
    O: 'static + TypeInfo,
    P: 'static + TypeInfo,
    Q: 'static + TypeInfo,
    R: 'static + TypeInfo,
    S: 'static + TypeInfo,
    T: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for u128

type Identity = u128

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I> TypeInfo for (A, B, C, D, E, F, G, H, I) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I)

pub fn type_info() -> Type<MetaForm>

impl<'_, T> TypeInfo for &'_ mut T where
    T: 'static + TypeInfo + ?Sized, 

type Identity = T

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E> TypeInfo for (A, B, C, D, E) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo, 

type Identity = (A, B, C, D, E)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for i32

type Identity = i32

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for String

type Identity = str

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for i128

type Identity = i128

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo,
    N: 'static + TypeInfo,
    O: 'static + TypeInfo,
    P: 'static + TypeInfo,
    Q: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for bool

type Identity = bool

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for i8

type Identity = i8

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo,
    N: 'static + TypeInfo,
    O: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

pub fn type_info() -> Type<MetaForm>

impl<K, V> TypeInfo for BTreeMap<K, V> where
    K: 'static + TypeInfo,
    V: 'static + TypeInfo, 

type Identity = BTreeMap<K, V>

pub fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for BTreeSet<T> where
    T: 'static + TypeInfo, 

type Identity = BTreeSet<T>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for ()

type Identity = ()

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for str

type Identity = str

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G> TypeInfo for (A, B, C, D, E, F, G) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G)

pub fn type_info() -> Type<MetaForm>

impl<'_, T> TypeInfo for &'_ T where
    T: 'static + TypeInfo + ?Sized, 

type Identity = T

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU16

type Identity = NonZeroU16

pub fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Box<T, Global> where
    T: 'static + TypeInfo + ?Sized, 

type Identity = T

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for i16

type Identity = i16

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI64

type Identity = NonZeroI64

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for u32

type Identity = u32

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI128

type Identity = NonZeroI128

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for u16

type Identity = u16

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI8

type Identity = NonZeroI8

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo,
    N: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU64

type Identity = NonZeroU64

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU128

type Identity = NonZeroU128

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F> TypeInfo for (A, B, C, D, E, F) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for char

type Identity = char

pub fn type_info() -> Type<MetaForm>

impl<Idx> TypeInfo for Range<Idx> where
    Idx: 'static + TypeInfo + PartialOrd<Idx> + Debug, 

type Identity = Range<Idx>

pub fn type_info() -> Type<MetaForm>

impl<A, B> TypeInfo for (A, B) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo, 

type Identity = (A, B)

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H> TypeInfo for (A, B, C, D, E, F, G, H) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H)

pub fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Compact<T> where
    T: 'static + TypeInfo, 

type Identity = Compact<T>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI32

type Identity = NonZeroI32

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K)

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L)

pub fn type_info() -> Type<MetaForm>

impl<A, B, C> TypeInfo for (A, B, C) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo, 

type Identity = (A, B, C)

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J> TypeInfo for (A, B, C, D, E, F, G, H, I, J) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J)

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU8

type Identity = NonZeroU8

pub fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for VecDeque<T, Global> where
    T: 'static + TypeInfo, 

type Identity = [T]

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU32

type Identity = NonZeroU32

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D> TypeInfo for (A, B, C, D) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo, 

type Identity = (A, B, C, D)

pub fn type_info() -> Type<MetaForm>

impl<Idx> TypeInfo for RangeInclusive<Idx> where
    Idx: 'static + TypeInfo + PartialOrd<Idx> + Debug, 

type Identity = RangeInclusive<Idx>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for u64

type Identity = u64

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI16

type Identity = NonZeroI16

pub fn type_info() -> Type<MetaForm>

impl<T, const N: usize> TypeInfo for [T; N] where
    T: 'static + TypeInfo, 

type Identity = [T; N]

pub fn type_info() -> Type<MetaForm>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> TypeInfo for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    A: 'static + TypeInfo,
    B: 'static + TypeInfo,
    C: 'static + TypeInfo,
    D: 'static + TypeInfo,
    E: 'static + TypeInfo,
    F: 'static + TypeInfo,
    G: 'static + TypeInfo,
    H: 'static + TypeInfo,
    I: 'static + TypeInfo,
    J: 'static + TypeInfo,
    K: 'static + TypeInfo,
    L: 'static + TypeInfo,
    M: 'static + TypeInfo,
    N: 'static + TypeInfo,
    O: 'static + TypeInfo,
    P: 'static + TypeInfo,
    Q: 'static + TypeInfo,
    R: 'static + TypeInfo, 

type Identity = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

pub fn type_info() -> Type<MetaForm>

impl<A> TypeInfo for (A,) where
    A: 'static + TypeInfo, 

type Identity = (A,)

pub fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Cow<'static, T> where
    T: 'static + ToOwned + TypeInfo + ?Sized, 

type Identity = Cow<'static, T>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for AccountId32

type Identity = AccountId32

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for KeyTypeId

type Identity = KeyTypeId

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for OpaqueNetworkState

type Identity = OpaqueNetworkState

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for OpaqueMultiaddr

type Identity = OpaqueMultiaddr

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for OpaquePeerId

type Identity = OpaquePeerId

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for U256

type Identity = U256

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for H256

type Identity = H256

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for U512

type Identity = U512

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for H512

type Identity = H512

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for H160

type Identity = H160

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for H128

type Identity = H128

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for U128

type Identity = U128

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for CompactProof

type Identity = CompactProof

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for StorageProof

type Identity = StorageProof

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for MultiSignature

type Identity = MultiSignature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for UintAuthorityId

type Identity = UintAuthorityId

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for BlakeTwo256

type Identity = BlakeTwo256

pub fn type_info() -> Type<MetaForm>

impl<Call, Extra> TypeInfo for TestXt<Call, Extra> where
    Call: 'static + TypeInfo,
    Extra: 'static + TypeInfo,
    Option<(u64, Extra)>: 'static,
    Option<(u64, Extra)>: TypeInfo, 

type Identity = TestXt<Call, Extra>

pub fn type_info() -> Type<MetaForm>

impl<Address, Call, Signature, Extra> TypeInfo for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Address: StaticTypeInfo,
    Call: StaticTypeInfo,
    Signature: StaticTypeInfo,
    Extra: SignedExtension + StaticTypeInfo, 

Manual TypeInfo implementation because of custom encoding. The data is a valid encoded Vec<u8>, but requires some logic to extract the signature and payload.

See UncheckedExtrinsic::encode and UncheckedExtrinsic::decode.

type Identity = UncheckedExtrinsic<Address, Call, Signature, Extra>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for TokenError

type Identity = TokenError

pub fn type_info() -> Type<MetaForm>

impl<Number, Hash> TypeInfo for Header<Number, Hash> where
    Number: Copy + Into<U256> + TryFrom<U256> + HasCompact + 'static + TypeInfo,
    Hash: Hash + 'static + TypeInfo,
    <Hash as Hash>::Output: 'static,
    <Hash as Hash>::Output: TypeInfo, 

type Identity = Header<Number, Hash>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for TestSignature

type Identity = TestSignature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for ArithmeticError

type Identity = ArithmeticError

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Era

type Identity = Era

pub fn type_info() -> Type<MetaForm>

impl<'a> TypeInfo for PiecewiseLinear<'a> where
    'a: 'static, 

type Identity = PiecewiseLinear<'a>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for RuntimeString

type Identity = str

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for DigestItem

type Identity = DigestItem

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Keccak256

type Identity = Keccak256

pub fn type_info() -> Type<MetaForm>

impl<AccountId, AccountIndex> TypeInfo for MultiAddress<AccountId, AccountIndex> where
    AccountId: 'static + TypeInfo,
    AccountIndex: HasCompact + 'static + TypeInfo, 

type Identity = MultiAddress<AccountId, AccountIndex>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Digest

type Identity = Digest

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for MultiSigner

type Identity = MultiSigner

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Perquintill

type Identity = Perquintill

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Perbill

type Identity = Perbill

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for PerU16

type Identity = PerU16

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for FixedI128

type Identity = FixedI128

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for FixedU128

type Identity = FixedU128

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Percent

type Identity = Percent

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for FixedI64

type Identity = FixedI64

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for Permill

type Identity = Permill

pub fn type_info() -> Type<MetaForm>

impl<Reporter, Offender> TypeInfo for OffenceDetails<Reporter, Offender> where
    Offender: 'static + TypeInfo,
    Reporter: 'static + TypeInfo,
    Vec<Reporter, Global>: 'static,
    Vec<Reporter, Global>: TypeInfo, 

type Identity = OffenceDetails<Reporter, Offender>

pub fn type_info() -> Type<MetaForm>

impl TypeInfo for DisableStrategy

type Identity = DisableStrategy

pub fn type_info() -> Type<MetaForm>

Implementors

impl TypeInfo for Never

type Identity = Self

impl TypeInfo for Void

type Identity = Void

impl TypeInfo for BalanceStatus

type Identity = Self

impl TypeInfo for DispatchClass

type Identity = Self

impl TypeInfo for Pays

type Identity = Self

impl TypeInfo for DispatchError

type Identity = DispatchError

impl TypeInfo for PalletId

type Identity = Self

impl TypeInfo for DispatchInfo

type Identity = Self

impl TypeInfo for PostDispatchInfo

type Identity = Self

impl TypeInfo for RuntimeDbWeight

type Identity = Self

impl<'a, T, S> TypeInfo for BoundedSlice<'a, T, S> where
    'a: 'static,
    &'a [T]: TypeInfo + 'static,
    PhantomData<S>: TypeInfo + 'static,
    T: TypeInfo + 'static,
    S: 'static, 

type Identity = Self

impl<Balance> TypeInfo for WeightToFeeCoefficient<Balance> where
    Balance: TypeInfo + 'static,
    Balance: TypeInfo + 'static, 

type Identity = Self

impl<BlockNumber> TypeInfo for DispatchTime<BlockNumber> where
    BlockNumber: TypeInfo + 'static,
    BlockNumber: TypeInfo + 'static,
    BlockNumber: TypeInfo + 'static, 

type Identity = Self

impl<K, V, S> TypeInfo for BoundedBTreeMap<K, V, S> where
    BTreeMap<K, V>: TypeInfo + 'static,
    PhantomData<S>: TypeInfo + 'static,
    K: TypeInfo + 'static,
    V: TypeInfo + 'static,
    S: 'static, 

type Identity = Self

impl<T> TypeInfo for Vec<T, Global> where
    T: 'static + TypeInfo, 

type Identity = [T]

impl<T> TypeInfo for PerDispatchClass<T> where
    T: TypeInfo + 'static,
    T: TypeInfo + 'static,
    T: TypeInfo + 'static,
    T: TypeInfo + 'static, 

type Identity = Self

impl<T> TypeInfo for PhantomData<T>

type Identity = PhantomData<()>

impl<T, E> TypeInfo for Result<T, E> where
    T: 'static + TypeInfo,
    E: 'static + TypeInfo, 

type Identity = Result<T, E>

impl<T, S> TypeInfo for BoundedBTreeSet<T, S> where
    BTreeSet<T>: TypeInfo + 'static,
    PhantomData<S>: TypeInfo + 'static,
    T: TypeInfo + 'static,
    S: 'static, 

type Identity = Self

impl<T, S> TypeInfo for BoundedVec<T, S> where
    Vec<T>: TypeInfo + 'static,
    PhantomData<S>: TypeInfo + 'static,
    T: TypeInfo + 'static,
    S: 'static, 

type Identity = Self

impl<T, S> TypeInfo for WeakBoundedVec<T, S> where
    Vec<T>: TypeInfo + 'static,
    PhantomData<S>: TypeInfo + 'static,
    T: TypeInfo + 'static,
    S: 'static, 

type Identity = Self

impl<T: TypeInfo + 'static> TypeInfo for WrapperKeepOpaque<T>

type Identity = Self

impl<T: TypeInfo + 'static> TypeInfo for WrapperOpaque<T>

type Identity = Self