diff --git a/derive/src/lib.rs b/derive/src/lib.rs
index 73cbdd5b..511c0bec 100644
--- a/derive/src/lib.rs
+++ b/derive/src/lib.rs
@@ -19,7 +19,13 @@ extern crate proc_macro;
 
 mod impl_wrapper;
 
-use alloc::vec::Vec;
+use alloc::{
+    string::{
+        String,
+        ToString,
+    },
+    vec::Vec,
+};
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
@@ -104,19 +110,38 @@ fn generate_fields(fields: &FieldsList) -> Vec<TokenStream2> {
         .iter()
         .map(|f| {
             let (ty, ident) = (&f.ty, &f.ident);
+            let type_name = clean_type_string(&quote!(#ty).to_string());
+
             if let Some(i) = ident {
                 quote! {
-                    .field_of::<#ty>(stringify!(#i))
+                    .field_of::<#ty>(stringify!(#i), #type_name)
                 }
             } else {
                 quote! {
-                    .field_of::<#ty>()
+                    .field_of::<#ty>(#type_name)
                 }
             }
         })
         .collect()
 }
 
+fn clean_type_string(input: &str) -> String {
+    input
+        .replace(" ::", "::")
+        .replace(":: ", "::")
+        .replace(" ,", ",")
+        .replace(" ;", ";")
+        .replace(" [", "[")
+        .replace("[ ", "[")
+        .replace(" ]", "]")
+        .replace(" (", "(")
+        .replace("( ", "(")
+        .replace(" )", ")")
+        .replace(" <", "<")
+        .replace("< ", "<")
+        .replace(" >", ">")
+}
+
 fn generate_composite_type(data_struct: &DataStruct) -> TokenStream2 {
     let fields = match data_struct.fields {
         Fields::Named(ref fs) => {
diff --git a/src/build.rs b/src/build.rs
index ed150f12..4832b3e1 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -39,8 +39,8 @@
 //!             .path(Path::new("Foo", module_path!()))
 //!             .type_params(vec![MetaType::new::<T>()])
 //!             .composite(Fields::named()
-//!                 .field_of::<T>("bar")
-//!                 .field_of::<u64>("data")
+//!                 .field_of::<T>("bar", "T")
+//!                 .field_of::<u64>("data", "u64")
 //!             )
 //!     }
 //! }
@@ -57,8 +57,8 @@
 //!         Type::builder()
 //!             .path(Path::new("Foo", module_path!()))
 //!             .composite(Fields::unnamed()
-//!                 .field_of::<u32>()
-//!                 .field_of::<bool>()
+//!                 .field_of::<u32>("u32")
+//!                 .field_of::<bool>("bool")
 //!             )
 //!     }
 //! }
@@ -84,8 +84,8 @@
 //!                .type_params(vec![MetaType::new::<T>()])
 //!             .variant(
 //!                 Variants::with_fields()
-//!                     .variant("A", Fields::unnamed().field_of::<T>())
-//!                     .variant("B", Fields::named().field_of::<u32>("f"))
+//!                     .variant("A", Fields::unnamed().field_of::<T>("T"))
+//!                     .variant("B", Fields::named().field_of::<u32>("f", "u32"))
 //!                     .variant("C", Fields::unit())
 //!             )
 //!     }
@@ -177,12 +177,12 @@ impl TypeBuilder<state::PathAssigned> {
 
     /// Construct a "variant" type i.e an `enum`
     pub fn variant<V>(self, builder: VariantsBuilder<V>) -> Type {
-        self.build(builder.done())
+        self.build(builder.finalize())
     }
 
     /// Construct a "composite" type i.e. a `struct`
     pub fn composite<F>(self, fields: FieldsBuilder<F>) -> Type {
-        self.build(TypeDefComposite::new(fields.done()))
+        self.build(TypeDefComposite::new(fields.finalize()))
     }
 }
 
@@ -226,7 +226,7 @@ impl Fields {
 
 /// Build a set of either all named (e.g. for a struct) or all unnamed (e.g. for a tuple struct)
 pub struct FieldsBuilder<T> {
-    fields: Vec<Field<MetaForm>>,
+    fields: Vec<Field>,
     marker: PhantomData<fn() -> T>,
 }
 
@@ -241,41 +241,29 @@ impl<T> Default for FieldsBuilder<T> {
 
 impl<T> FieldsBuilder<T> {
     /// Complete building and return the set of fields
-    pub fn done(self) -> Vec<Field<MetaForm>> {
+    pub fn finalize(self) -> Vec<Field<MetaForm>> {
         self.fields
     }
 }
 
 impl FieldsBuilder<NamedFields> {
-    /// Add a named field with the given [`MetaType`](`crate::MetaType`) instance
-    pub fn field(mut self, name: &'static str, ty: MetaType) -> Self {
-        self.fields.push(Field::named(name, ty));
-        self
-    }
-
     /// Add a named field with the type of the type parameter `T`
-    pub fn field_of<T>(mut self, name: &'static str) -> Self
+    pub fn field_of<T>(mut self, name: &'static str, type_name: &'static str) -> Self
     where
         T: TypeInfo + ?Sized + 'static,
     {
-        self.fields.push(Field::named_of::<T>(name));
+        self.fields.push(Field::named_of::<T>(name, type_name));
         self
     }
 }
 
 impl FieldsBuilder<UnnamedFields> {
-    /// Add an unnamed field with the given [`MetaType`](`crate::MetaType`) instance
-    pub fn field(mut self, ty: MetaType) -> Self {
-        self.fields.push(Field::unnamed(ty));
-        self
-    }
-
     /// Add an unnamed field with the type of the type parameter `T`
-    pub fn field_of<T>(mut self) -> Self
+    pub fn field_of<T>(mut self, type_name: &'static str) -> Self
     where
         T: TypeInfo + ?Sized + 'static,
     {
-        self.fields.push(Field::unnamed_of::<T>());
+        self.fields.push(Field::unnamed_of::<T>(type_name));
         self
     }
 }
@@ -341,7 +329,7 @@ impl<T> VariantsBuilder<T> {
         }
     }
 
-    fn done(self) -> TypeDefVariant {
+    fn finalize(self) -> TypeDefVariant {
         TypeDefVariant::new(self.variants)
     }
 }
diff --git a/src/impls.rs b/src/impls.rs
index 9554b589..25d4cc49 100644
--- a/src/impls.rs
+++ b/src/impls.rs
@@ -121,7 +121,7 @@ where
             .variant(
                 Variants::with_fields()
                     .variant_unit("None")
-                    .variant("Some", Fields::unnamed().field_of::<T>()),
+                    .variant("Some", Fields::unnamed().field_of::<T>("T")),
             )
     }
 }
@@ -139,8 +139,8 @@ where
             .type_params(tuple_meta_type!(T, E))
             .variant(
                 Variants::with_fields()
-                    .variant("Ok", Fields::unnamed().field_of::<T>())
-                    .variant("Err", Fields::unnamed().field_of::<E>()),
+                    .variant("Ok", Fields::unnamed().field_of::<T>("T"))
+                    .variant("Err", Fields::unnamed().field_of::<E>("E")),
             )
     }
 }
@@ -156,7 +156,7 @@ where
         Type::builder()
             .path(Path::prelude("BTreeMap"))
             .type_params(tuple_meta_type![(K, V)])
-            .composite(Fields::unnamed().field_of::<[(K, V)]>())
+            .composite(Fields::unnamed().field_of::<[(K, V)]>("[(K, V)]"))
     }
 }
 
diff --git a/src/registry.rs b/src/registry.rs
index 609a1db3..fd539be4 100644
--- a/src/registry.rs
+++ b/src/registry.rs
@@ -266,10 +266,17 @@ mod tests {
                     .path(Path::new("RecursiveRefs", module_path!()))
                     .composite(
                         Fields::named()
-                            .field_of::<Box<RecursiveRefs>>("boxed")
-                            .field_of::<&'static RecursiveRefs<'static>>("reference")
+                            .field_of::<Box<RecursiveRefs>>(
+                                "boxed",
+                                "Box < RecursiveRefs >",
+                            )
+                            .field_of::<&'static RecursiveRefs<'static>>(
+                                "reference",
+                                "&RecursiveRefs",
+                            )
                             .field_of::<&'static mut RecursiveRefs<'static>>(
                                 "mutable_reference",
+                                "&mut RecursiveRefs",
                             ),
                     )
                     .into()
diff --git a/src/tests.rs b/src/tests.rs
index ccb9b8af..1552490c 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -60,7 +60,7 @@ fn prelude_items() {
             .variant(
                 Variants::with_fields()
                     .variant_unit("None")
-                    .variant("Some", Fields::unnamed().field_of::<u128>())
+                    .variant("Some", Fields::unnamed().field_of::<u128>("T"))
             )
     );
     assert_type!(
@@ -70,8 +70,8 @@ fn prelude_items() {
             .type_params(tuple_meta_type!(bool, String))
             .variant(
                 Variants::with_fields()
-                    .variant("Ok", Fields::unnamed().field_of::<bool>())
-                    .variant("Err", Fields::unnamed().field_of::<String>())
+                    .variant("Ok", Fields::unnamed().field_of::<bool>("T"))
+                    .variant("Err", Fields::unnamed().field_of::<String>("E"))
             )
     );
     assert_type!(
@@ -133,7 +133,7 @@ fn struct_with_generics() {
             Type::builder()
                 .path(Path::new("MyStruct", module_path!()))
                 .type_params(tuple_meta_type!(T))
-                .composite(Fields::named().field_of::<T>("data"))
+                .composite(Fields::named().field_of::<T>("data", "T"))
                 .into()
         }
     }
@@ -142,7 +142,7 @@ fn struct_with_generics() {
     let struct_bool_type_info = Type::builder()
         .path(Path::from_segments(vec!["scale_info", "tests", "MyStruct"]).unwrap())
         .type_params(tuple_meta_type!(bool))
-        .composite(Fields::named().field_of::<bool>("data"));
+        .composite(Fields::named().field_of::<bool>("data", "T"));
 
     assert_type!(MyStruct<bool>, struct_bool_type_info);
 
@@ -151,6 +151,6 @@ fn struct_with_generics() {
     let expected_type = Type::builder()
         .path(Path::new("MyStruct", "scale_info::tests"))
         .type_params(tuple_meta_type!(Box<MyStruct<bool>>))
-        .composite(Fields::named().field_of::<Box<MyStruct<bool>>>("data"));
+        .composite(Fields::named().field_of::<Box<MyStruct<bool>>>("data", "T"));
     assert_type!(SelfTyped, expected_type);
 }
diff --git a/src/ty/fields.rs b/src/ty/fields.rs
index d4efcf66..687f55d0 100644
--- a/src/ty/fields.rs
+++ b/src/ty/fields.rs
@@ -39,7 +39,30 @@ use serde::{
 ///
 /// Name is optional so it can represent both named and unnamed fields.
 ///
-/// This can be a named field of a struct type or a struct variant.
+/// This can be a named field of a struct type or an enum struct variant.
+///
+/// # Type name
+///
+/// The `type_name` field contains a string which is the name of the type of the
+/// field as it appears in the source code. The exact contents and format of the
+/// type name are not specified, but in practice will be the name of any valid
+/// type for a field e.g.
+///
+///   - Concrete types e.g `"u32"`, `"bool"`, `"Foo"` etc.
+///   - Type parameters e.g `"T"`, `"U"`
+///   - Generic types e.g `"Vec<u32>"`, `"Vec<T>"`
+///   - Associated types e.g. `"T::MyType"`, `"<T as MyTrait>::MyType"`
+///   - Type aliases e.g. `"MyTypeAlias"`, `"MyTypeAlias<T>"`
+///   - Other built in Rust types e.g. arrays, references etc.
+///
+/// Note that the type name doesn't correspond to the underlying type of the
+/// field, unless using a concrete type directly. Any given type may be referred
+/// to by multiple field type names, when using generic type parameters and type
+/// aliases.
+///
+/// This is intended for informational and diagnostic purposes only. Although it
+/// is possible to infer certain properties e.g. whether a type name is a type alias,
+/// there are no guarantees provided, and the type name representation may change.
 #[derive(
     PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Serialize, Deserialize, Encode, Decode,
 )]
@@ -47,6 +70,7 @@ use serde::{
     serialize = "T::Type: Serialize, T::String: Serialize",
     deserialize = "T::Type: DeserializeOwned, T::String: DeserializeOwned"
 ))]
+#[serde(rename_all = "camelCase")]
 pub struct Field<T: Form = MetaForm> {
     /// The name of the field. None for unnamed fields.
     #[serde(skip_serializing_if = "Option::is_none", default)]
@@ -54,6 +78,8 @@ pub struct Field<T: Form = MetaForm> {
     /// The type of the field.
     #[serde(rename = "type")]
     ty: T::Type,
+    /// The name of the type of the field as it appears in the source code.
+    type_name: T::String,
 }
 
 impl IntoCompact for Field {
@@ -63,6 +89,7 @@ impl IntoCompact for Field {
         Field {
             name: self.name.map(|name| name.into_compact(registry)),
             ty: registry.register_type(&self.ty),
+            type_name: self.type_name.into_compact(registry),
         }
     }
 }
@@ -71,43 +98,38 @@ impl Field {
     /// Creates a new field.
     ///
     /// Use this constructor if you want to instantiate from a given meta type.
-    pub fn new(name: Option<&'static str>, ty: MetaType) -> Self {
-        Self { name, ty }
-    }
-
-    /// Creates a new named field
-    pub fn named(name: &'static str, ty: MetaType) -> Self {
-        Self::new(Some(name), ty)
+    pub fn new(
+        name: Option<&'static str>,
+        ty: MetaType,
+        type_name: &'static str,
+    ) -> Self {
+        Self {
+            name,
+            ty,
+            type_name,
+        }
     }
 
     /// Creates a new named field.
     ///
     /// Use this constructor if you want to instantiate from a given
     /// compile-time type.
-    pub fn named_of<T>(name: &'static str) -> Self
+    pub fn named_of<T>(name: &'static str, type_name: &'static str) -> Field
     where
         T: TypeInfo + ?Sized + 'static,
     {
-        Self::new(Some(name), MetaType::new::<T>())
-    }
-
-    /// Creates a new unnamed field.
-    ///
-    /// Use this constructor if you want to instantiate an unnamed field from a
-    /// given meta type.
-    pub fn unnamed(meta_type: MetaType) -> Self {
-        Self::new(None, meta_type)
+        Self::new(Some(name), MetaType::new::<T>(), type_name)
     }
 
     /// Creates a new unnamed field.
     ///
     /// Use this constructor if you want to instantiate an unnamed field from a
     /// given compile-time type.
-    pub fn unnamed_of<T>() -> Self
+    pub fn unnamed_of<T>(type_name: &'static str) -> Field
     where
         T: TypeInfo + ?Sized + 'static,
     {
-        Self::new(None, MetaType::new::<T>())
+        Self::new(None, MetaType::new::<T>(), type_name)
     }
 }
 
@@ -124,4 +146,13 @@ where
     pub fn ty(&self) -> &T::Type {
         &self.ty
     }
+
+    /// Returns a string which is the name of the type of the field as it
+    /// appears in the source code. The exact contents and format of the type
+    /// name are not specified, but in practice will be the name of any valid
+    /// type for a field. This is intended for informational and diagnostic
+    /// purposes only.
+    pub fn type_name(&self) -> &T::String {
+        &self.type_name
+    }
 }
diff --git a/src/ty/variant.rs b/src/ty/variant.rs
index 90b3313c..4541b5e7 100644
--- a/src/ty/variant.rs
+++ b/src/ty/variant.rs
@@ -186,7 +186,7 @@ impl Variant {
     pub fn with_fields<F>(name: &'static str, fields: FieldsBuilder<F>) -> Self {
         Self {
             name,
-            fields: fields.done(),
+            fields: fields.finalize(),
             discriminant: None,
         }
     }
diff --git a/test_suite/tests/derive.rs b/test_suite/tests/derive.rs
index 49e4bf50..ba7deede 100644
--- a/test_suite/tests/derive.rs
+++ b/test_suite/tests/derive.rs
@@ -55,7 +55,11 @@ fn struct_derive() {
     let struct_type = Type::builder()
         .path(Path::new("S", "derive"))
         .type_params(tuple_meta_type!(bool, u8))
-        .composite(Fields::named().field_of::<bool>("t").field_of::<u8>("u"));
+        .composite(
+            Fields::named()
+                .field_of::<bool>("t", "T")
+                .field_of::<u8>("u", "U"),
+        );
 
     assert_type!(S<bool, u8>, struct_type);
 
@@ -68,8 +72,8 @@ fn struct_derive() {
         .type_params(tuple_meta_type!(Box<S<bool, u8>>, bool))
         .composite(
             Fields::named()
-                .field_of::<Box<S<bool, u8>>>("t")
-                .field_of::<bool>("u"),
+                .field_of::<Box<S<bool, u8>>>("t", "T")
+                .field_of::<bool>("u", "U"),
         );
     assert_type!(SelfTyped, self_typed_type);
 }
@@ -83,7 +87,7 @@ fn tuple_struct_derive() {
     let ty = Type::builder()
         .path(Path::new("S", "derive"))
         .type_params(tuple_meta_type!(bool))
-        .composite(Fields::unnamed().field_of::<bool>());
+        .composite(Fields::unnamed().field_of::<bool>("T"));
 
     assert_type!(S<bool>, ty);
 }
@@ -132,8 +136,8 @@ fn enum_derive() {
         .type_params(tuple_meta_type!(bool))
         .variant(
             Variants::with_fields()
-                .variant("A", Fields::unnamed().field_of::<bool>())
-                .variant("B", Fields::named().field_of::<bool>("b"))
+                .variant("A", Fields::unnamed().field_of::<bool>("T"))
+                .variant("B", Fields::named().field_of::<bool>("b", "T"))
                 .variant_unit("C"),
         );
 
@@ -151,14 +155,31 @@ fn recursive_type_derive() {
 
     let ty = Type::builder().path(Path::new("Tree", "derive")).variant(
         Variants::with_fields()
-            .variant("Leaf", Fields::named().field_of::<i32>("value"))
+            .variant("Leaf", Fields::named().field_of::<i32>("value", "i32"))
             .variant(
                 "Node",
                 Fields::named()
-                    .field_of::<Box<Tree>>("right")
-                    .field_of::<Box<Tree>>("left"),
+                    .field_of::<Box<Tree>>("right", "Box<Tree>")
+                    .field_of::<Box<Tree>>("left", "Box<Tree>"),
             ),
     );
 
     assert_type!(Tree, ty);
 }
+
+#[test]
+fn fields_with_type_alias() {
+    type BoolAlias = bool;
+
+    #[allow(unused)]
+    #[derive(TypeInfo)]
+    struct S {
+        a: BoolAlias,
+    }
+
+    let ty = Type::builder()
+        .path(Path::new("S", "derive"))
+        .composite(Fields::named().field_of::<BoolAlias>("a", "BoolAlias"));
+
+    assert_type!(S, ty);
+}
diff --git a/test_suite/tests/json.rs b/test_suite/tests/json.rs
index d472893e..7306d273 100644
--- a/test_suite/tests/json.rs
+++ b/test_suite/tests/json.rs
@@ -103,7 +103,7 @@ fn test_builtins() {
                     },
                     {
                         "name": "Some",
-                        "fields": [ { "type": 1 } ]
+                        "fields": [ { "type": 1, "typeName": "T" } ]
                     },
                 ]
             }
@@ -117,11 +117,11 @@ fn test_builtins() {
                 "variants": [
                     {
                         "name": "Ok",
-                        "fields": [ { "type": 1 } ]
+                        "fields": [ { "type": 1, "typeName": "T" } ]
                     },
                     {
                         "name": "Err",
-                        "fields": [ { "type": 2 } ]
+                        "fields": [ { "type": 2, "typeName": "E" } ]
                     }
                 ]
             }
@@ -171,9 +171,9 @@ fn test_tuplestruct() {
         "def": {
             "composite": {
                 "fields": [
-                    { "type": 1 },
-                    { "type": 2 },
-                    { "type": 4 },
+                    { "type": 1, "typeName": "i32" },
+                    { "type": 2, "typeName": "[u8; 32]" },
+                    { "type": 4, "typeName": "bool" },
                 ],
             },
         }
@@ -194,9 +194,9 @@ fn test_struct() {
         "def": {
             "composite": {
                 "fields": [
-                    { "name": "a", "type": 1, },
-                    { "name": "b", "type": 2, },
-                    { "name": "c", "type": 4, },
+                    { "name": "a", "type": 1, "typeName": "i32" },
+                    { "name": "b", "type": 2, "typeName": "[u8; 32]" },
+                    { "name": "c", "type": 4, "typeName": "bool" },
                 ],
             },
         }
@@ -244,16 +244,16 @@ fn test_enum() {
                     {
                         "name": "TupleStructVariant",
                         "fields": [
-                            { "type": 1 },
-                            { "type": 2 },
+                            { "type": 1, "typeName": "u32" },
+                            { "type": 2, "typeName": "bool" },
                         ],
                     },
                     {
                         "name": "StructVariant",
                         "fields": [
-                            { "name": "a", "type": 1, },
-                            { "name": "b", "type": 3, },
-                            { "name": "c", "type": 5, },
+                            { "name": "a", "type": 1, "typeName": "u32" },
+                            { "name": "b", "type": 3, "typeName": "[u8; 32]" },
+                            { "name": "c", "type": 5, "typeName": "char" },
                         ],
                     }
                 ],
@@ -283,14 +283,14 @@ fn test_recursive_type_with_box() {
                             {
                                 "name": "Leaf",
                                 "fields": [
-                                    { "name": "value", "type": 2 },
+                                    { "name": "value", "type": 2, "typeName": "i32" },
                                 ],
                             },
                             {
                                 "name": "Node",
                                 "fields": [
-                                    { "name": "right", "type": 1, },
-                                    { "name": "left", "type": 1, },
+                                    { "name": "right", "type": 1, "typeName": "Box<Tree>" },
+                                    { "name": "left", "type": 1, "typeName": "Box<Tree>" },
                                 ],
                             }
                         ],
@@ -363,8 +363,8 @@ fn test_registry() {
                 "def": {
                     "composite": {
                         "fields": [
-                            { "type": 3 },
-                            { "type": 4 },
+                            { "type": 3, "typeName": "u8" },
+                            { "type": 4, "typeName": "u32" },
                         ],
                     },
                 }
@@ -385,15 +385,18 @@ fn test_registry() {
                         "fields": [
                             {
                                 "name": "a",
-                                "type": 3, // u8
+                                "type": 3,
+                                "typeName": "u8"
                             },
                             {
                                 "name": "b",
-                                "type": 4, // u32
+                                "type": 4,
+                                "typeName": "u32"
                             },
                             {
                                 "name": "c",
-                                "type": 6, // [u8; 32]
+                                "type": 6,
+                                "typeName": "[u8; 32]"
                             }
                         ]
                     },
@@ -417,7 +420,8 @@ fn test_registry() {
                         "fields": [
                             {
                                 "name": "rec",
-                                "type": 8, // Vec<RecursiveStruct>
+                                "type": 8,
+                                "typeName": "Vec<RecursiveStruct>"
                             }
                         ]
                     },
@@ -468,8 +472,8 @@ fn test_registry() {
                             {
                                 "name": "B",
                                 "fields": [
-                                    { "type": 3 }, // u8
-                                    { "type": 4 }, // u32
+                                    { "type": 3, "typeName": "u8" }, // u8
+                                    { "type": 4, "typeName": "u32" }, // u32
                                 ]
                             },
                             {
@@ -478,14 +482,17 @@ fn test_registry() {
                                     {
                                         "name": "a",
                                         "type": 3, // u8
+                                        "typeName": "u8"
                                     },
                                     {
                                         "name": "b",
                                         "type": 4, // u32
+                                        "typeName": "u32"
                                     },
                                     {
                                         "name": "c",
-                                        "type": 6, // [u8; 32]
+                                        "type": 6,
+                                        "typeName": "[u8; 32]"
                                     }
                                 ]
                             }