diff --git a/tools/macro-utils/src/field_utils.rs b/tools/macro-utils/src/field_utils.rs
deleted file mode 100644
index 1c034095a..000000000
--- a/tools/macro-utils/src/field_utils.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use proc_macro::TokenStream;
-use quote::{quote, ToTokens};
-use syn::{parse, Data, DeriveInput, Result};
-
-pub fn expand(input: TokenStream) -> Result<TokenStream> {
-    let input: DeriveInput = parse(input)?;
-    let name = &input.ident;
-
-    let expanded = match input.data {
-        Data::Struct(data_struct) => {
-            let fields: Vec<_> = data_struct
-                .fields
-                .iter()
-                .filter(|f| {
-                    f.attrs
-                        .iter()
-                        .find(|attr| attr.path().is_ident("skip_field"))
-                        .is_none()
-                })
-                .map(|f| {
-                    let field = f.ident.as_ref().map(|i| i.to_string()).unwrap_or_default();
-                    let type_str = f.ty.to_token_stream().to_string();
-                    quote! {
-                        (#field, #type_str)
-                    }
-                })
-                .collect::<Vec<_>>();
-            quote! {
-                impl #name {
-                    pub fn fields() -> &'static[(&'static str, &'static str)] {
-                        &[ #(#fields),* ]
-                    }
-                }
-            }
-        }
-        Data::Enum(data_enum) => {
-            let variants: Vec<_> = data_enum.variants.into_iter().map(|v| v.ident).collect();
-            quote! {
-                impl #name {
-                    pub fn values() -> &'static[#name] {
-                        &[ #(#name::#variants),* ]
-                    }
-                }
-            }
-        }
-        Data::Union(data_union) => {
-            let fields: Vec<_> = data_union
-                .fields
-                .named
-                .iter()
-                .filter(|f| {
-                    f.attrs
-                        .iter()
-                        .find(|attr| attr.path().is_ident("skip_field"))
-                        .is_none()
-                })
-                .map(|f| {
-                    let field = f.ident.as_ref().map(|i| i.to_string()).unwrap_or_default();
-                    let type_str = f.ty.to_token_stream().to_string();
-                    quote! {
-                        (#field, #type_str)
-                    }
-                })
-                .collect::<Vec<_>>();
-            quote! {
-                impl #name {
-                    pub fn fields() -> &'static[(&'static str, &'static str)] {
-                        &[ #(#fields),* ]
-                    }
-                }
-            }
-        }
-    };
-    Ok(TokenStream::from(expanded))
-}
diff --git a/tools/macro-utils/src/lib.rs b/tools/macro-utils/src/lib.rs
index 5afcd0e24..4f6551bf3 100644
--- a/tools/macro-utils/src/lib.rs
+++ b/tools/macro-utils/src/lib.rs
@@ -2,41 +2,8 @@ extern crate proc_macro2;
 
 use proc_macro::TokenStream;
 
-mod field_utils;
 mod struct_utils;
 
-/// Implements either:
-///     #values() -> &'static[#Enum] for enums that returns all defined values in the enum.
-///     #fields() -> &'static[(field_name, field_type_definition)] for struct and union types that returns all defined fields.
-/// E.g.
-/// ```
-/// use macro_utils::VariantExport;
-/// #[derive(VariantExport, PartialEq, Debug)]
-/// pub enum SomeEnum {
-///     SomeValue1,
-///     SomeValue2
-/// }
-///
-/// assert_eq!([SomeEnum::SomeValue1, SomeEnum::SomeValue2], SomeEnum::values());
-/// 
-/// pub struct B;
-/// 
-/// #[derive(VariantExport)]
-/// pub struct A {
-///     x: i64,
-///     y: i128,
-///     z: B
-/// }
-///
-/// assert_eq!([("x", "i64"), ("y", "i128"), ("z", "B")], A::fields());
-/// ```
-#[proc_macro_derive(VariantExport)]
-pub fn field_values(input: TokenStream) -> TokenStream {
-    field_utils::expand(input)
-        .unwrap_or_else(|e| e.into_compile_error().into())
-        .into()
-}
-
 /// Implements a way to fetch all public implemented method for a given struct or trait.
 /// It returns a tuple where the first element is the functions name and the second if its async
 /// E.g.