Trait pallet_nft::types::TypeInfo

pub trait TypeInfo {
    type Identity: 'static + ?Sized;

    fn type_info() -> Type<MetaForm>;
}

Implementors return their meta type information.

Required 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 LookupError

type Identity = LookupError

fn type_info() -> Type<MetaForm>

impl TypeInfo for DispatchInfo

type Identity = DispatchInfo

fn type_info() -> Type<MetaForm>

impl TypeInfo for Pays

type Identity = Pays

fn type_info() -> Type<MetaForm>

impl TypeInfo for PalletId

type Identity = PalletId

fn type_info() -> Type<MetaForm>

impl TypeInfo for RuntimeDbWeight

type Identity = RuntimeDbWeight

fn type_info() -> Type<MetaForm>

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

type Identity = PerDispatchClass<T>

fn type_info() -> Type<MetaForm>

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

type Identity = DispatchTime<BlockNumber>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Weight

type Identity = Weight

fn type_info() -> Type<MetaForm>

impl TypeInfo for DispatchClass

type Identity = DispatchClass

fn type_info() -> Type<MetaForm>

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

type Identity = WrapperKeepOpaque<T>

fn type_info() -> Type<MetaForm>

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

type Identity = MaybeHashed<T, Hash>

fn type_info() -> Type<MetaForm>

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

type Identity = WeightToFeeCoefficient<Balance>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Never

type Identity = Never

fn type_info() -> Type<MetaForm>

impl TypeInfo for BalanceStatus

type Identity = BalanceStatus

fn type_info() -> Type<MetaForm>

impl TypeInfo for PostDispatchInfo

type Identity = PostDispatchInfo

fn type_info() -> Type<MetaForm>

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

type Identity = WrapperOpaque<T>

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)

fn type_info() -> Type<MetaForm>

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

type Identity = (A, B)

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)

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for PhantomData<T>

type Identity = PhantomData<()>

fn type_info() -> Type<MetaForm>

impl TypeInfo for bool

type Identity = bool

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)

fn type_info() -> Type<MetaForm>

impl TypeInfo for u64

type Identity = u64

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI16

type Identity = NonZeroI16

fn type_info() -> Type<MetaForm>

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

type Identity = [T]

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI32

type Identity = NonZeroI32

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI128

type Identity = NonZeroI128

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)

fn type_info() -> Type<MetaForm>

impl TypeInfo for u128

type Identity = u128

fn type_info() -> Type<MetaForm>

impl TypeInfo for u32

type Identity = u32

fn type_info() -> Type<MetaForm>

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

type Identity = RangeInclusive<Idx>

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU16

type Identity = NonZeroU16

fn type_info() -> Type<MetaForm>

impl TypeInfo for i128

type Identity = i128

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)

fn type_info() -> Type<MetaForm>

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

type Identity = BTreeMap<K, V, Global>

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU64

type Identity = NonZeroU64

fn type_info() -> Type<MetaForm>

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

type Identity = Result<T, E>

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU8

type Identity = NonZeroU8

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)

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)

fn type_info() -> Type<MetaForm>

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

type Identity = Compact<T>

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU32

type Identity = NonZeroU32

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)

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroU128

type Identity = NonZeroU128

fn type_info() -> Type<MetaForm>

impl TypeInfo for String

type Identity = str

fn type_info() -> Type<MetaForm>

impl TypeInfo for i64

type Identity = i64

fn type_info() -> Type<MetaForm>

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

type Identity = Option<T>

fn type_info() -> Type<MetaForm>

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

type Identity = T

fn type_info() -> Type<MetaForm>

impl TypeInfo for u8

type Identity = u8

fn type_info() -> Type<MetaForm>

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

type Identity = BTreeSet<T, Global>

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)

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI64

type Identity = NonZeroI64

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)

fn type_info() -> Type<MetaForm>

impl TypeInfo for str

type Identity = str

fn type_info() -> Type<MetaForm>

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

type Identity = (A,)

fn type_info() -> Type<MetaForm>

impl TypeInfo for i8

type Identity = i8

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)

fn type_info() -> Type<MetaForm>

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

type Identity = T

fn type_info() -> Type<MetaForm>

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

type Identity = [T; N]

fn type_info() -> Type<MetaForm>

impl TypeInfo for u16

type Identity = u16

fn type_info() -> Type<MetaForm>

impl TypeInfo for i16

type Identity = i16

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)

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)

fn type_info() -> Type<MetaForm>

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

type Identity = [T]

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)

fn type_info() -> Type<MetaForm>

impl TypeInfo for ()

type Identity = ()

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)

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)

fn type_info() -> Type<MetaForm>

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

type Identity = T

fn type_info() -> Type<MetaForm>

impl TypeInfo for NonZeroI8

type Identity = NonZeroI8

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)

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)

fn type_info() -> Type<MetaForm>

impl TypeInfo for char

type Identity = char

fn type_info() -> Type<MetaForm>

impl TypeInfo for i32

type Identity = i32

fn type_info() -> Type<MetaForm>

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

type Identity = Range<Idx>

fn type_info() -> Type<MetaForm>

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

type Identity = Cow<'static, T>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

fn type_info() -> Type<MetaForm>

impl TypeInfo for OpaquePeerId

type Identity = OpaquePeerId

fn type_info() -> Type<MetaForm>

impl TypeInfo for AccountId32

type Identity = AccountId32

fn type_info() -> Type<MetaForm>

impl TypeInfo for OpaqueNetworkState

type Identity = OpaqueNetworkState

fn type_info() -> Type<MetaForm>

impl TypeInfo for OpaqueMultiaddr

type Identity = OpaqueMultiaddr

fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

fn type_info() -> Type<MetaForm>

impl TypeInfo for KeyTypeId

type Identity = KeyTypeId

fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

fn type_info() -> Type<MetaForm>

impl TypeInfo for Void

type Identity = Void

fn type_info() -> Type<MetaForm>

impl TypeInfo for U256

type Identity = U256

fn type_info() -> Type<MetaForm>

impl TypeInfo for U512

type Identity = U512

fn type_info() -> Type<MetaForm>

impl TypeInfo for H128

type Identity = H128

fn type_info() -> Type<MetaForm>

impl TypeInfo for H160

type Identity = H160

fn type_info() -> Type<MetaForm>

impl TypeInfo for H256

type Identity = H256

fn type_info() -> Type<MetaForm>

impl TypeInfo for H512

type Identity = H512

fn type_info() -> Type<MetaForm>

impl TypeInfo for U128

type Identity = U128

fn type_info() -> Type<MetaForm>

impl TypeInfo for CompactProof

type Identity = CompactProof

fn type_info() -> Type<MetaForm>

impl TypeInfo for StorageProof

type Identity = StorageProof

fn type_info() -> Type<MetaForm>

impl TypeInfo for DispatchError

type Identity = DispatchError

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>

fn type_info() -> Type<MetaForm>

impl TypeInfo for TransactionValidityError

type Identity = TransactionValidityError

fn type_info() -> Type<MetaForm>

impl TypeInfo for UintAuthorityId

type Identity = UintAuthorityId

fn type_info() -> Type<MetaForm>

impl TypeInfo for ModuleError

type Identity = ModuleError

fn type_info() -> Type<MetaForm>

impl TypeInfo for UnknownTransaction

type Identity = UnknownTransaction

fn type_info() -> Type<MetaForm>

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

type Identity = TestXt<Call, Extra>

fn type_info() -> Type<MetaForm>

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

type Identity = BoundedBTreeSet<T, S>

fn type_info() -> Type<MetaForm>

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

type Identity = BoundedSlice<'a, T, S>

fn type_info() -> Type<MetaForm>

impl<Info> TypeInfo for DispatchErrorWithPostInfo<Info>where
    Info: Eq + PartialEq<Info> + Clone + Copy + Encode + Decode + Printable + 'static + TypeInfo,

type Identity = DispatchErrorWithPostInfo<Info>

fn type_info() -> Type<MetaForm>

impl TypeInfo for ModuleError

type Identity = ModuleError

fn type_info() -> Type<MetaForm>

impl TypeInfo for TokenError

type Identity = TokenError

fn type_info() -> Type<MetaForm>

impl TypeInfo for MultiSignature

type Identity = MultiSignature

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>

fn type_info() -> Type<MetaForm>

impl TypeInfo for TransactionalError

type Identity = TransactionalError

fn type_info() -> Type<MetaForm>

impl TypeInfo for ArithmeticError

type Identity = ArithmeticError

fn type_info() -> Type<MetaForm>

impl TypeInfo for DigestItem

type Identity = DigestItem

fn type_info() -> Type<MetaForm>

impl TypeInfo for RuntimeString

type Identity = str

fn type_info() -> Type<MetaForm>

impl TypeInfo for BlakeTwo256

type Identity = BlakeTwo256

fn type_info() -> Type<MetaForm>

impl TypeInfo for Keccak256

type Identity = Keccak256

fn type_info() -> Type<MetaForm>

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

type Identity = WeakBoundedVec<T, S>

fn type_info() -> Type<MetaForm>

impl TypeInfo for InvalidTransaction

type Identity = InvalidTransaction

fn type_info() -> Type<MetaForm>

impl TypeInfo for DispatchError

type Identity = DispatchError

fn type_info() -> Type<MetaForm>

impl TypeInfo for OpaqueExtrinsic

type Identity = OpaqueExtrinsic

fn type_info() -> Type<MetaForm>

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

type Identity = BoundedVec<T, S>

fn type_info() -> Type<MetaForm>

impl TypeInfo for MultiSigner

type Identity = MultiSigner

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 + TypeInfo,

type Identity = Header<Number, Hash>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Digest

type Identity = Digest

fn type_info() -> Type<MetaForm>

impl TypeInfo for PiecewiseLinear<'static>

type Identity = PiecewiseLinear<'static>

fn type_info() -> Type<MetaForm>

impl TypeInfo for TestSignature

type Identity = TestSignature

fn type_info() -> Type<MetaForm>

impl TypeInfo for Era

type Identity = Era

fn type_info() -> Type<MetaForm>

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

type Identity = BoundedBTreeMap<K, V, S>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

fn type_info() -> Type<MetaForm>

impl TypeInfo for Public

type Identity = Public

fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

fn type_info() -> Type<MetaForm>

impl TypeInfo for Signature

type Identity = Signature

fn type_info() -> Type<MetaForm>

impl TypeInfo for Perquintill

type Identity = Perquintill

fn type_info() -> Type<MetaForm>

impl TypeInfo for Percent

type Identity = Percent

fn type_info() -> Type<MetaForm>

impl TypeInfo for Perbill

type Identity = Perbill

fn type_info() -> Type<MetaForm>

impl TypeInfo for PerU16

type Identity = PerU16

fn type_info() -> Type<MetaForm>

impl TypeInfo for Permill

type Identity = Permill

fn type_info() -> Type<MetaForm>

impl TypeInfo for FixedI128

type Identity = FixedI128

fn type_info() -> Type<MetaForm>

impl TypeInfo for FixedU64

type Identity = FixedU64

fn type_info() -> Type<MetaForm>

impl TypeInfo for FixedI64

type Identity = FixedI64

fn type_info() -> Type<MetaForm>

impl TypeInfo for FixedU128

type Identity = FixedU128

fn type_info() -> Type<MetaForm>

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

type Identity = OffenceDetails<Reporter, Offender>

fn type_info() -> Type<MetaForm>

impl TypeInfo for DisableStrategy

type Identity = DisableStrategy

fn type_info() -> Type<MetaForm>

impl TypeInfo for RuntimeVersion

type Identity = RuntimeVersion

fn type_info() -> Type<MetaForm>

impl TypeInfo for BlockLength

type Identity = BlockLength

fn type_info() -> Type<MetaForm>

impl TypeInfo for WeightsPerClass

type Identity = WeightsPerClass

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for CheckNonZeroSender<T>where
    T: Config + Send + Sync + 'static,
    PhantomData<T>: 'static + TypeInfo,

type Identity = CheckNonZeroSender<T>

fn type_info() -> Type<MetaForm>

impl<E, T> TypeInfo for EventRecord<E, T>where
    E: Parameter + Member + 'static + TypeInfo,
    Vec<T, Global>: 'static + TypeInfo,
    T: 'static + TypeInfo,

type Identity = EventRecord<E, T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for CheckGenesis<T>where
    T: Config + Send + Sync + 'static,
    PhantomData<T>: 'static + TypeInfo,

type Identity = CheckGenesis<T>

fn type_info() -> Type<MetaForm>

impl<Index, AccountData> TypeInfo for AccountInfo<Index, AccountData>where
    Index: 'static + TypeInfo,
    AccountData: 'static + TypeInfo,

type Identity = AccountInfo<Index, AccountData>

fn type_info() -> Type<MetaForm>

impl TypeInfo for BlockWeights

type Identity = BlockWeights

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for CheckWeight<T>where
    T: Config + Send + Sync + 'static,
    PhantomData<T>: 'static + TypeInfo,

type Identity = CheckWeight<T>

fn type_info() -> Type<MetaForm>

impl TypeInfo for LastRuntimeUpgradeInfo

type Identity = LastRuntimeUpgradeInfo

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for CheckTxVersion<T>where
    T: Config + Send + Sync + 'static,
    PhantomData<T>: 'static + TypeInfo,

type Identity = CheckTxVersion<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for CheckSpecVersion<T>where
    T: Config + Send + Sync + 'static,
    PhantomData<T>: 'static + TypeInfo,

type Identity = CheckSpecVersion<T>

fn type_info() -> Type<MetaForm>

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

type Identity = Error<T>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Phase

type Identity = Phase

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Event<T>where
    T: Config + 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config>::Hash: 'static + TypeInfo,
    PhantomData<T>: 'static + TypeInfo,

type Identity = Event<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for CheckNonce<T>where
    T: Config + 'static,
    <T as Config>::Index: HasCompact,

type Identity = CheckNonce<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for CheckMortality<T>where
    T: Config + Send + Sync + 'static,
    PhantomData<T>: 'static + TypeInfo,

type Identity = CheckMortality<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Call<T>where
    T: Config + 'static,
    PhantomData<(T,)>: 'static + TypeInfo,

type Identity = Call<T>

fn type_info() -> Type<MetaForm>

impl<AccountId, DepositBalance> TypeInfo for CollectionDetails<AccountId, DepositBalance>where
    AccountId: 'static + TypeInfo,
    DepositBalance: 'static + TypeInfo,

type Identity = CollectionDetails<AccountId, DepositBalance>

fn type_info() -> Type<MetaForm>

impl<DepositBalance, StringLimit> TypeInfo for CollectionMetadata<DepositBalance, StringLimit>where
    StringLimit: Get<u32> + 'static,
    DepositBalance: 'static + TypeInfo,
    BoundedVec<u8, StringLimit>: 'static + TypeInfo,

type Identity = CollectionMetadata<DepositBalance, StringLimit>

fn type_info() -> Type<MetaForm>

impl<AccountId, DepositBalance> TypeInfo for ItemDetails<AccountId, DepositBalance>where
    AccountId: 'static + TypeInfo,
    Option<AccountId>: 'static + TypeInfo,
    DepositBalance: 'static + TypeInfo,

type Identity = ItemDetails<AccountId, DepositBalance>

fn type_info() -> Type<MetaForm>

impl<T, I> TypeInfo for Event<T, I>where
    T: Config<I> + 'static,
    I: 'static,
    <T as Config<I>>::CollectionId: 'static + TypeInfo,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config<I>>::ItemId: 'static + TypeInfo,
    BoundedVec<u8, <T as Config<I>>::StringLimit>: 'static + TypeInfo,
    Vec<<T as Config<I>>::ItemId, Global>: 'static + TypeInfo,
    Option<<T as Config<I>>::ItemId>: 'static + TypeInfo,
    BoundedVec<u8, <T as Config<I>>::KeyLimit>: 'static + TypeInfo,
    BoundedVec<u8, <T as Config<I>>::ValueLimit>: 'static + TypeInfo,
    Option<<T as Config<I>>::CollectionId>: 'static + TypeInfo,
    <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: 'static + TypeInfo,
    Option<<T as Config>::AccountId>: 'static + TypeInfo,
    PhantomData<(T, I)>: 'static + TypeInfo,

type Identity = Event<T, I>

fn type_info() -> Type<MetaForm>

impl TypeInfo for DestroyWitness

type Identity = DestroyWitness

fn type_info() -> Type<MetaForm>

impl<T, I> TypeInfo for Error<T, I>where
    PhantomData<(T, I)>: 'static + TypeInfo,
    T: 'static,
    I: 'static,

type Identity = Error<T, I>

fn type_info() -> Type<MetaForm>

impl<DepositBalance, StringLimit> TypeInfo for ItemMetadata<DepositBalance, StringLimit>where
    StringLimit: Get<u32> + 'static,
    DepositBalance: 'static + TypeInfo,
    BoundedVec<u8, StringLimit>: 'static + TypeInfo,

type Identity = ItemMetadata<DepositBalance, StringLimit>

fn type_info() -> Type<MetaForm>

impl<T, I> TypeInfo for Call<T, I>where
    T: Config<I> + 'static,
    I: 'static,
    PhantomData<(T, I)>: 'static + TypeInfo,
    <T as Config<I>>::CollectionId: 'static + TypeInfo,
    <<T as Config>::Lookup as StaticLookup>::Source: 'static + TypeInfo,
    <T as Config<I>>::ItemId: 'static + TypeInfo,
    Option<<<T as Config>::Lookup as StaticLookup>::Source>: 'static + TypeInfo,
    Vec<<T as Config<I>>::ItemId, Global>: 'static + TypeInfo,
    Option<<T as Config<I>>::ItemId>: 'static + TypeInfo,
    BoundedVec<u8, <T as Config<I>>::KeyLimit>: 'static + TypeInfo,
    BoundedVec<u8, <T as Config<I>>::ValueLimit>: 'static + TypeInfo,
    BoundedVec<u8, <T as Config<I>>::StringLimit>: 'static + TypeInfo,
    Option<<T as Config<I>>::CollectionId>: 'static + TypeInfo,
    Option<<<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance>: 'static + TypeInfo,
    <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: 'static + TypeInfo,

type Identity = Call<T, I>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Representative<T>where
    T: Config + 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config>::BlockNumber: 'static + TypeInfo,
    Vec<<T as Config>::AccountId, Global>: 'static + TypeInfo,

type Identity = Representative<T>

fn type_info() -> Type<MetaForm>

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

type Identity = Error<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Notary<T>where
    T: Config + 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config>::BlockNumber: 'static + TypeInfo,

type Identity = Notary<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Event<T>where
    T: Config + 'static,
    <T as Config>::BlockNumber: 'static + TypeInfo,
    <T as Config>::AccountId: 'static + TypeInfo,
    PhantomData<T>: 'static + TypeInfo,

type Identity = Event<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Tenant<T>where
    T: Config + 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: 'static + TypeInfo,
    <T as Config>::BlockNumber: 'static + TypeInfo,
    Option<<T as Config>::AccountId>: 'static + TypeInfo,

type Identity = Tenant<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Servicer<T>where
    T: Config + 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config>::BlockNumber: 'static + TypeInfo,

type Identity = Servicer<T>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Accounts

type Identity = Accounts

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for HouseSeller<T>where
    T: Config + 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config>::BlockNumber: 'static + TypeInfo,

type Identity = HouseSeller<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Investor<T>where
    T: Config + 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config>::BlockNumber: 'static + TypeInfo,
    <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: 'static + TypeInfo,

type Identity = Investor<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Call<T>where
    T: Config + 'static,
    PhantomData<(T,)>: 'static + TypeInfo,
    <T as Config>::AccountId: 'static + TypeInfo,
    <<T as Config>::Lookup as StaticLookup>::Source: 'static + TypeInfo,

type Identity = Call<T>

fn type_info() -> Type<MetaForm>

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

type Identity = Error<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Event<T>where
    T: Config + 'static,
    Option<<T as Config>::AccountId>: 'static + TypeInfo,
    PhantomData<T>: 'static + TypeInfo,

type Identity = Event<T>

fn type_info() -> Type<MetaForm>

impl<T> TypeInfo for Call<T>where
    T: Config + 'static,
    PhantomData<(T,)>: 'static + TypeInfo,
    Box<<T as Config>::Call, Global>: 'static + TypeInfo,
    <<T as Config>::Lookup as StaticLookup>::Source: 'static + TypeInfo,

type Identity = Call<T>

fn type_info() -> Type<MetaForm>

impl<T, I> TypeInfo for Event<T, I>where
    T: Config<I> + 'static,
    I: 'static,
    <T as Config>::AccountId: 'static + TypeInfo,
    <T as Config<I>>::Balance: 'static + TypeInfo,
    PhantomData<(T, I)>: 'static + TypeInfo,

type Identity = Event<T, I>

fn type_info() -> Type<MetaForm>

impl TypeInfo for Reasons

type Identity = Reasons

fn type_info() -> Type<MetaForm>

impl<T, I> TypeInfo for Call<T, I>where
    T: Config<I> + 'static,
    I: 'static,
    PhantomData<(T, I)>: 'static + TypeInfo,
    <<T as Config>::Lookup as StaticLookup>::Source: 'static + TypeInfo,
    <T as Config<I>>::Balance: HasCompact + 'static + TypeInfo,

type Identity = Call<T, I>

fn type_info() -> Type<MetaForm>

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

type Identity = BalanceLock<Balance>

fn type_info() -> Type<MetaForm>

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

type Identity = ReserveData<ReserveIdentifier, Balance>

fn type_info() -> Type<MetaForm>

impl<T, I> TypeInfo for Error<T, I>where
    PhantomData<(T, I)>: 'static + TypeInfo,
    T: 'static,
    I: 'static,

type Identity = Error<T, I>

fn type_info() -> Type<MetaForm>

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

type Identity = AccountData<Balance>

fn type_info() -> Type<MetaForm>

Implementors

impl TypeInfo for PossibleCollections

type Identity = PossibleCollections

impl TypeInfo for NftPermissions

type Identity = NftPermissions

impl<AccountId> TypeInfo for RawOrigin<AccountId>where
    AccountId: 'static + TypeInfo,

type Identity = RawOrigin<AccountId>

impl<BoundedVec> TypeInfo for CollectionInfo<BoundedVec>where
    BoundedVec: TypeInfo + 'static,

type Identity = CollectionInfo<BoundedVec>

impl<BoundedVec> TypeInfo for ItemInfo<BoundedVec>where
    BoundedVec: TypeInfo + 'static,

type Identity = ItemInfo<BoundedVec>

impl<T> TypeInfo for pallet_nft::pallet::Call<T>where
    PhantomData<(T,)>: TypeInfo + 'static,
    BoundedVecOfUnq<T>: TypeInfo + 'static,
    T::NftItemId: TypeInfo + 'static,
    <T::Lookup as StaticLookup>::Source: TypeInfo + 'static,
    T: Config + 'static,

type Identity = Call<T>

impl<T> TypeInfo for pallet_nft::pallet::Error<T>where
    PhantomData<T>: TypeInfo + 'static,
    T: 'static,

type Identity = Error<T>

impl<T> TypeInfo for pallet_nft::pallet::Event<T>where
    T::AccountId: TypeInfo + 'static,
    T::NftCollectionId: TypeInfo + 'static,
    T::NftItemId: TypeInfo + 'static,
    PhantomData<T>: TypeInfo + 'static,
    T: Config + 'static,

type Identity = Event<T>

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

type Identity = [T]