diff --git a/examples/functions.rs b/examples/functions.rs
new file mode 100644
index 0000000..0957148
--- /dev/null
+++ b/examples/functions.rs
@@ -0,0 +1,3 @@
+fn main() {
+    // TODO: Show an example of building a function exporter.
+}
diff --git a/macros/src/data_type_from/mod.rs b/macros/src/data_type_from/mod.rs
index f8d702a..8e7e88e 100644
--- a/macros/src/data_type_from/mod.rs
+++ b/macros/src/data_type_from/mod.rs
@@ -65,7 +65,7 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
                     #[automatically_derived]
                     impl From<#ident> for #crate_ref::StructType {
                         fn from(t: #ident) -> #crate_ref::StructType {
-                            #crate_ref::internal::construct::r#struct(#struct_name.into(), vec![], #crate_ref::internal::construct::struct_named(vec![#(#fields),*], None))
+                            #crate_ref::internal::construct::r#struct(#struct_name, vec![], #crate_ref::internal::construct::struct_named(vec![#(#fields),*], None))
                         }
                     }
 
diff --git a/macros/src/fn_datatype.rs b/macros/src/fn_datatype.rs
deleted file mode 100644
index 76e0e52..0000000
--- a/macros/src/fn_datatype.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use crate::utils::format_fn_wrapper;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{
-    parse::{Parse, ParseStream},
-    Ident, Path, PathArguments, Token,
-};
-
-pub struct FnDatatypeInput {
-    type_map: Ident,
-    function: Path,
-}
-
-impl Parse for FnDatatypeInput {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let type_map: Ident = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let function: Path = input.parse()?;
-
-        Ok(Self { type_map, function })
-    }
-}
-
-pub fn proc_macro(
-    FnDatatypeInput { type_map, function }: FnDatatypeInput,
-) -> syn::Result<TokenStream> {
-    let mut specta_fn_macro = function.clone();
-
-    let last = specta_fn_macro
-        .segments
-        .last_mut()
-        .expect("Function path is empty!");
-
-    last.ident = format_fn_wrapper(&last.ident.clone());
-    last.arguments = PathArguments::None;
-
-    Ok(quote! {
-        specta::functions::get_datatype_internal(
-            #function as #specta_fn_macro!(@signature),
-            #specta_fn_macro!(@asyncness),
-            #specta_fn_macro!(@name),
-            #type_map,
-            #specta_fn_macro!(@arg_names),
-            #specta_fn_macro!(@docs)
-        )
-    })
-}
diff --git a/macros/src/lib.rs b/macros/src/lib.rs
index 2b13fa8..cd36f77 100644
--- a/macros/src/lib.rs
+++ b/macros/src/lib.rs
@@ -4,12 +4,11 @@
 //! You shouldn't need to use this crate directly.
 //! Checkout [Specta](https://docs.rs/specta).
 //!
+
 #[macro_use]
 mod utils;
 mod data_type_from;
 #[cfg(feature = "functions")]
-mod fn_datatype;
-#[cfg(feature = "functions")]
 mod specta;
 mod r#type;
 
@@ -31,13 +30,3 @@ pub fn specta(
 ) -> proc_macro::TokenStream {
     specta::attribute(item).unwrap_or_else(|err| err.into_compile_error().into())
 }
-
-#[proc_macro]
-#[cfg(feature = "functions")]
-pub fn fn_datatype(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    use syn::parse_macro_input;
-
-    fn_datatype::proc_macro(parse_macro_input!(input as fn_datatype::FnDatatypeInput))
-        .unwrap_or_else(|err| err.into_compile_error())
-        .into()
-}
diff --git a/macros/src/specta.rs b/macros/src/specta.rs
index 5ce4525..ec6b2c3 100644
--- a/macros/src/specta.rs
+++ b/macros/src/specta.rs
@@ -1,13 +1,14 @@
 // inspired by https://github.com/tauri-apps/tauri/blob/2901145c497299f033ba7120af5f2e7ead16c75a/core/tauri-macros/src/command/handler.rs
 
 use quote::{quote, ToTokens};
-use syn::{parse_macro_input, FnArg, ItemFn, Pat, Visibility};
+use syn::{parse_macro_input, FnArg, ItemFn, Pat, ReturnType, Visibility};
 
 use crate::utils::format_fn_wrapper;
 
 pub fn attribute(item: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenStream> {
     let function = parse_macro_input::parse::<ItemFn>(item)?;
     let wrapper = format_fn_wrapper(&function.sig.ident);
+    let crate_ref = quote!(specta);
 
     let visibility = &function.vis;
     let maybe_macro_export = match &visibility {
@@ -15,26 +16,34 @@ pub fn attribute(item: proc_macro::TokenStream) -> syn::Result<proc_macro::Token
         _ => Default::default(),
     };
 
-    let function_name = &function.sig.ident;
-    let function_name_str = function_name.to_string();
-    let function_asyncness = match function.sig.asyncness {
-        Some(_) => true,
-        None => false,
-    };
+    let ident = &function.sig.ident;
+    let name = ident.to_string();
+    let asyncness = function.sig.asyncness.is_some();
 
-    let arg_names = function.sig.inputs.iter().map(|input| match input {
-        FnArg::Receiver(_) => unreachable!("Commands cannot take 'self'"),
-        FnArg::Typed(arg) => match &*arg.pat {
-            Pat::Ident(ident) => ident.ident.to_token_stream(),
-            Pat::Macro(m) => m.mac.tokens.to_token_stream(),
-            Pat::Struct(s) => s.path.to_token_stream(),
-            Pat::Slice(s) => s.attrs[0].to_token_stream(),
-            Pat::Tuple(s) => s.elems[0].to_token_stream(),
-            _ => unreachable!("Commands must take named arguments"),
-        },
-    });
+    let args = function.sig.inputs.iter().map(|input| match input {
+        FnArg::Receiver(_) => return Err(syn::Error::new_spanned(
+            input,
+            "functions with `#[specta]` cannot take 'self'",
+        )),
+        FnArg::Typed(arg) => {
+            let name = &arg.pat.to_token_stream().to_string();
+            let ty = &arg.ty;
+            Ok(quote!(
+                (
+                    #name.into(),
+                    <#ty as #crate_ref::internal::functions::FunctionArg<_>>::to_datatype(#crate_ref::DefOpts {
+                        parent_inline: false,
+                        type_map,
+                    })
+                )
+            ))
+        }
+    }).collect::<syn::Result<Vec<_>>>()?;
 
-    let arg_signatures = function.sig.inputs.iter().map(|_| quote!(_));
+    let output = match &function.sig.output {
+        ReturnType::Default => quote!(()),
+        ReturnType::Type(_, ty) => quote!(#ty),
+    };
 
     let docs = function
         .attrs
@@ -51,11 +60,37 @@ pub fn attribute(item: proc_macro::TokenStream) -> syn::Result<proc_macro::Token
         #maybe_macro_export
         #[doc(hidden)]
         macro_rules! #wrapper {
-            (@asyncness) => { #function_asyncness };
-            (@name) => { #function_name_str.into() };
-            (@arg_names) => { &[#(stringify!(#arg_names).into()),* ] };
-            (@signature) => { fn(#(#arg_signatures),*) -> _ };
-            (@docs) => { vec![#(#docs.into()),*] };
+            (@internal) => {{
+                // fn export_self(type_map: &mut #crate_ref::TypeMap) -> #crate_ref::FunctionType {
+                //     #crate_ref::internal::construct::function_type(
+                //         #asyncness,
+                //         #name,
+                //         vec![#(#args),*],
+                //         <#output as #crate_ref::internal::functions::FunctionOutput<_>>::to_datatype(#crate_ref::DefOpts {
+                //             parent_inline: false,
+                //             type_map,
+                //         }),
+                //         vec![#(#docs.into()),*]
+                //     )
+                // }
+                // export_self as fn(&mut _) -> _
+
+                let f: fn(&mut _) -> _ = |type_map| {
+                    // todo!();
+                    #crate_ref::internal::construct::function_type(
+                        #asyncness,
+                        #name,
+                        vec![#(#args),*],
+                        <#output as #crate_ref::internal::functions::FunctionOutput<_>>::to_datatype(#crate_ref::DefOpts {
+                            parent_inline: false,
+                            type_map,
+                        }),
+                        vec![#(#docs.into()),*]
+                    )
+                };
+
+                #crate_ref::internal::construct::function(&f)
+            }}
         }
 
         // allow the macro to be resolved with the same path as the function
diff --git a/macros/src/type/enum.rs b/macros/src/type/enum.rs
index b8b23cf..95bb6ad 100644
--- a/macros/src/type/enum.rs
+++ b/macros/src/type/enum.rs
@@ -202,11 +202,11 @@ pub fn parse_enum(
     };
 
     Ok((
-        quote!(#crate_ref::DataType::Enum(#crate_ref::internal::construct::r#enum(#name.into(), #repr, vec![#(#definition_generics),*], vec![#(#variant_types),*]))),
+        quote!(#crate_ref::DataType::Enum(#crate_ref::internal::construct::r#enum(#name, #repr, vec![#(#definition_generics),*], vec![#(#variant_types),*]))),
         quote!({
             let generics = vec![#(#reference_generics),*];
             #crate_ref::reference::reference::<Self>(opts, &generics, #crate_ref::internal::construct::data_type_reference(
-                #name.into(),
+                #name,
                 SID,
                 generics.clone() // TODO: This `clone` is cringe
             ))
diff --git a/macros/src/type/mod.rs b/macros/src/type/mod.rs
index cb13aa6..bf3e551 100644
--- a/macros/src/type/mod.rs
+++ b/macros/src/type/mod.rs
@@ -102,9 +102,9 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
 
         quote! {
             #[allow(non_snake_case)]
-            #[#crate_ref::internal::ctor::ctor]
+            #[#crate_ref::internal::__specta_ctor]
             fn #export_fn_name() {
-                #crate_ref::export::register_ty::<#ident<#(#generic_params),*>>();
+                #crate_ref::internal::export::register_ty::<#ident<#(#generic_params),*>>();
             }
         }
     });
@@ -152,7 +152,7 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
 
                 fn named_data_type(opts: #crate_ref::DefOpts, generics: &[#crate_ref::DataType]) -> #crate_ref::NamedDataType {
                     #crate_ref::internal::construct::named_data_type(
-                        #name.into(),
+                        #name,
                         #comments,
                         #deprecated,
                         SID,
diff --git a/macros/src/type/struct.rs b/macros/src/type/struct.rs
index 2c82481..4d4b9dd 100644
--- a/macros/src/type/struct.rs
+++ b/macros/src/type/struct.rs
@@ -228,7 +228,7 @@ pub fn parse_struct(
             Fields::Unit => quote!(#crate_ref::internal::construct::struct_unit()),
         };
 
-        quote!(#crate_ref::DataType::Struct(#crate_ref::internal::construct::r#struct(#name.into(), vec![#(#definition_generics),*], #fields)))
+        quote!(#crate_ref::DataType::Struct(#crate_ref::internal::construct::r#struct(#name, vec![#(#definition_generics),*], #fields)))
     };
 
  
@@ -242,7 +242,7 @@ pub fn parse_struct(
         quote!({
             let generics = vec![#(#reference_generics),*];
             #crate_ref::reference::reference::<Self>(opts, &generics, #crate_ref::internal::construct::data_type_reference(
-                #name.into(),
+                #name,
                 SID,
                 generics.clone() // TODO: This `clone` is cringe
             ))
diff --git a/src/type/post_process.rs b/src/advanced/duplicate_ty_name.rs
similarity index 98%
rename from src/type/post_process.rs
rename to src/advanced/duplicate_ty_name.rs
index fa1a9a6..a7a931a 100644
--- a/src/type/post_process.rs
+++ b/src/advanced/duplicate_ty_name.rs
@@ -3,7 +3,6 @@ use std::{borrow::Cow, collections::HashMap};
 use crate::{ImplLocation, TypeMap};
 
 /// post process the type map to detect duplicate type names
-#[doc(hidden)]
 pub fn detect_duplicate_type_names(
     type_map: &TypeMap,
 ) -> Vec<(Cow<'static, str>, ImplLocation, ImplLocation)> {
diff --git a/src/advanced/mod.rs b/src/advanced/mod.rs
new file mode 100644
index 0000000..1e91bd9
--- /dev/null
+++ b/src/advanced/mod.rs
@@ -0,0 +1,7 @@
+//! Advanced functionality, targeted for people building libraries with Specta.
+
+mod duplicate_ty_name;
+mod serde;
+
+pub use duplicate_ty_name::*;
+pub use serde::*;
diff --git a/src/serde.rs b/src/advanced/serde.rs
similarity index 100%
rename from src/serde.rs
rename to src/advanced/serde.rs
diff --git a/src/datatype/function.rs b/src/datatype/function.rs
new file mode 100644
index 0000000..f800073
--- /dev/null
+++ b/src/datatype/function.rs
@@ -0,0 +1,49 @@
+use std::borrow::Cow;
+
+use crate::{DataType, Function, TypeMap};
+
+/// Contains type information about a function annotated with [`specta`](macro@crate::specta).
+/// Returned by [`func`].
+#[derive(Debug, Clone, PartialEq)]
+pub struct FunctionType {
+    pub(crate) asyncness: bool,
+    pub(crate) name: Cow<'static, str>,
+    pub(crate) args: Vec<(Cow<'static, str>, DataType)>,
+    pub(crate) result: DataType,
+    pub(crate) docs: Vec<Cow<'static, str>>,
+}
+
+impl FunctionType {
+    /// Constructs a [`FunctionType`] from a [`Function`].
+    pub fn new<const N: usize>(
+        function: [Function; N],
+        type_map: &mut TypeMap,
+    ) -> [FunctionType; N] {
+        todo!();
+    }
+
+    /// Returns whether the function is async.
+    pub fn asyncness(&self) -> bool {
+        self.asyncness
+    }
+
+    /// Returns the function's name.
+    pub fn name(&self) -> &Cow<'static, str> {
+        &self.name
+    }
+
+    /// Returns the name and type of each of the function's arguments.
+    pub fn args(&self) -> &Vec<(Cow<'static, str>, DataType)> {
+        &self.args
+    }
+
+    /// Returns the return type of the function.
+    pub fn result(&self) -> &DataType {
+        &self.result
+    }
+
+    /// Returns the function's documentation. Detects both `///` and `#[doc = ...]` style documentation.
+    pub fn docs(&self) -> &Vec<Cow<'static, str>> {
+        &self.docs
+    }
+}
diff --git a/src/datatype/mod.rs b/src/datatype/mod.rs
index c147681..be8b16e 100644
--- a/src/datatype/mod.rs
+++ b/src/datatype/mod.rs
@@ -5,6 +5,8 @@ use std::{
 
 mod r#enum;
 mod fields;
+#[cfg(feature = "functions")]
+mod function;
 mod literal;
 mod named;
 mod primitive;
@@ -12,6 +14,9 @@ mod r#struct;
 mod tuple;
 
 pub use fields::*;
+#[cfg(feature = "functions")]
+#[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
+pub use function::*;
 pub use literal::*;
 pub use named::*;
 pub use primitive::*;
diff --git a/src/export/export.rs b/src/export/export.rs
index 3f9ffc7..8d86324 100644
--- a/src/export/export.rs
+++ b/src/export/export.rs
@@ -3,7 +3,7 @@ use once_cell::sync::Lazy;
 use std::sync::{PoisonError, RwLock, RwLockReadGuard};
 
 // Global type store for collecting custom types to export.
-static TYPES: Lazy<RwLock<TypeMap>> = Lazy::new(Default::default);
+pub(crate) static TYPES: Lazy<RwLock<TypeMap>> = Lazy::new(Default::default);
 
 /// A lock type for iterating over the internal type map.
 ///
@@ -34,18 +34,3 @@ pub fn get_types() -> TypesIter {
         lock: types,
     }
 }
-
-// Called within ctor functions to register a type.
-#[doc(hidden)]
-pub fn register_ty<T: Type>() {
-    let type_map = &mut *TYPES.write().unwrap_or_else(PoisonError::into_inner);
-
-    // We call this for it's side effects on the `type_map`
-    T::reference(
-        DefOpts {
-            parent_inline: false,
-            type_map,
-        },
-        &[],
-    );
-}
diff --git a/src/function.rs b/src/function.rs
new file mode 100644
index 0000000..b6f5cff
--- /dev/null
+++ b/src/function.rs
@@ -0,0 +1,49 @@
+//! Support for exporting Rust function.
+//!
+//! TODO: Docs. Talk about how Specta doesn't export functions but it helps you to.
+
+use crate::{FunctionType, TypeMap};
+
+pub(crate) type ExportFn = &'static dyn Fn(&mut TypeMap) -> FunctionType;
+
+pub struct Function {
+    pub(crate) export_fn: ExportFn,
+}
+
+/// Returns a [`FunctionDataType`] for a given function that has been annotated with
+/// [`specta`](macro@crate::specta).
+///
+/// # Examples
+///
+/// ```rust
+/// use specta::{specta, func};
+///
+/// #[specta]
+/// fn some_function(name: String, age: i32) -> bool {
+///     true
+/// }
+///
+/// fn main() {
+///     let typ = func!(some_function);
+///
+///     assert_eq!(typ.name, "some_function");
+///     assert_eq!(typ.args.len(), 2);
+///     assert_eq!(typ.result, DataType::Primitive(PrimitiveType::bool));
+/// }
+/// ```
+#[macro_export]
+macro_rules! func {
+    ($($function:path),* $(,)?) => {{
+        // TODO: This caps out at `12` variants. Can we fix it?
+        fn infer_array<const N: usize>(funcs: impl Into<[$crate::Function; N]>) -> [$crate::Function; N] {
+            funcs.into()
+        }
+
+        infer_array((
+
+            $(
+                $crate::internal::__specta_paste! { [< __specta__fn__ $function>]!(@internal) },
+            )*
+        ))
+    }};
+}
diff --git a/src/functions/arg.rs b/src/functions/arg.rs
deleted file mode 100644
index c88989e..0000000
--- a/src/functions/arg.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-mod private {
-    use crate::{DataType, DefOpts, Type};
-
-    /// Implemented by types that can be used as an argument in a function annotated with
-    /// [`specta`](crate::specta).
-    pub trait SpectaFunctionArg<TMarker> {
-        /// Gets the type of an argument as a [`DataType`].
-        ///
-        /// Some argument types should be ignored (eg Tauri command State),
-        /// so the value is optional.
-        fn to_datatype(opts: DefOpts) -> Option<DataType>;
-    }
-
-    pub enum FunctionArgMarker {}
-
-    impl<T: Type> SpectaFunctionArg<FunctionArgMarker> for T {
-        fn to_datatype(opts: DefOpts) -> Option<DataType> {
-            Some(T::reference(opts, &[]).inner)
-        }
-    }
-
-    #[cfg(feature = "tauri")]
-    const _: () = {
-        pub enum FunctionArgTauriMarker {}
-
-        impl<R: tauri::Runtime> SpectaFunctionArg<FunctionArgTauriMarker> for tauri::Window<R> {
-            fn to_datatype(_: DefOpts) -> Option<DataType> {
-                None
-            }
-        }
-
-        impl<'r, T: Send + Sync + 'static> SpectaFunctionArg<FunctionArgTauriMarker>
-            for tauri::State<'r, T>
-        {
-            fn to_datatype(_: DefOpts) -> Option<DataType> {
-                None
-            }
-        }
-
-        impl<R: tauri::Runtime> SpectaFunctionArg<FunctionArgTauriMarker> for tauri::AppHandle<R> {
-            fn to_datatype(_: DefOpts) -> Option<DataType> {
-                None
-            }
-        }
-    };
-}
-
-pub(crate) use private::SpectaFunctionArg;
diff --git a/src/functions/mod.rs b/src/functions/mod.rs
deleted file mode 100644
index 9b8b435..0000000
--- a/src/functions/mod.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-mod arg;
-mod result;
-
-use std::borrow::Cow;
-
-pub(crate) use arg::*;
-pub(crate) use result::*;
-
-use crate::*;
-
-/// Returns a [`FunctionDataType`] for a given function that has been annotated with
-/// [`specta`](macro@crate::specta).
-///
-/// # Examples
-///
-/// ```rust
-/// use specta::*;
-///
-/// #[specta]
-/// fn some_function(name: String, age: i32) -> bool {
-///     true
-/// }
-///
-/// fn main() {
-///     let typ = fn_datatype!(some_function);
-///
-///     assert_eq!(typ.name, "some_function");
-///     assert_eq!(typ.args.len(), 2);
-///     assert_eq!(typ.result, DataType::Primitive(PrimitiveType::bool));
-/// }
-/// ```
-#[macro_export]
-macro_rules! fn_datatype {
-    ($function:path) => {{
-        let mut type_map = $crate::TypeMap::default();
-
-        $crate::fn_datatype!(type_map; $function)
-    }};
-    ($type_map:ident; $function:path) => {{
-        let type_map: &mut $crate::TypeMap = &mut $type_map;
-
-        $crate::internal::fn_datatype!(type_map, $function)
-    }};
-}
-
-/// Contains type information about a function annotated with [`specta`](macro@crate::specta).
-/// Returned by [`fn_datatype`].
-#[derive(Debug, Clone)]
-pub struct FunctionDataType {
-    /// Whether the function is async.
-    pub asyncness: bool,
-    /// The function's name.
-    pub name: Cow<'static, str>,
-    /// The name and type of each of the function's arguments.
-    pub args: Vec<(Cow<'static, str>, DataType)>,
-    /// The return type of the function.
-    pub result: DataType,
-    /// The function's documentation. Detects both `///` and `#[doc = ...]` style documentation.
-    pub docs: Vec<Cow<'static, str>>,
-}
-
-/// Implemented by functions that can be annoatated with [`specta`](crate::specta).
-pub trait SpectaFunction<TMarker> {
-    /// Gets the type of a function as a [`FunctionDataType`].
-    fn to_datatype(
-        asyncness: bool,
-        name: Cow<'static, str>,
-        type_map: &mut TypeMap,
-        fields: &[Cow<'static, str>],
-        docs: Vec<Cow<'static, str>>,
-    ) -> FunctionDataType;
-}
-
-impl<TResultMarker, TResult: SpectaFunctionResult<TResultMarker>> SpectaFunction<TResultMarker>
-    for fn() -> TResult
-{
-    fn to_datatype(
-        asyncness: bool,
-        name: Cow<'static, str>,
-        type_map: &mut TypeMap,
-        _fields: &[Cow<'static, str>],
-        docs: Vec<Cow<'static, str>>,
-    ) -> FunctionDataType {
-        FunctionDataType {
-            asyncness,
-            name,
-            args: vec![],
-            result: TResult::to_datatype(DefOpts {
-                parent_inline: false,
-                type_map,
-            }),
-            docs,
-        }
-    }
-}
-
-#[doc(hidden)]
-/// A helper for exporting a command to a [`CommandDataType`].
-/// You shouldn't use this directly and instead should use [`fn_datatype!`](crate::fn_datatype).
-pub fn get_datatype_internal<TMarker, T: SpectaFunction<TMarker>>(
-    _: T,
-    asyncness: bool,
-    name: Cow<'static, str>,
-    type_map: &mut TypeMap,
-    fields: &[Cow<'static, str>],
-    docs: Vec<Cow<'static, str>>,
-) -> FunctionDataType {
-    T::to_datatype(asyncness, name, type_map, fields, docs)
-}
-
-macro_rules! impl_typed_command {
-    ( impl $($i:ident),* ) => {
-       paste::paste! {
-            impl<
-                TResultMarker,
-                TResult: SpectaFunctionResult<TResultMarker>,
-                $([<$i Marker>]),*,
-                $($i: SpectaFunctionArg<[<$i Marker>]>),*
-            > SpectaFunction<(TResultMarker, $([<$i Marker>]),*)> for fn($($i),*) -> TResult {
-                fn to_datatype(
-                    asyncness: bool,
-                    name: Cow<'static, str>,
-                    type_map: &mut TypeMap,
-                    fields: &[Cow<'static, str>],
-                    docs: Vec<Cow<'static, str>>,
-                ) -> FunctionDataType {
-                    let mut fields = fields.into_iter();
-
-                    FunctionDataType {
-                        asyncness,
-                        name,
-                        docs,
-                        args: [$(
-                            fields
-                                .next()
-                                .map_or_else(
-                                    || None,
-                                    |field| $i::to_datatype(DefOpts {
-                                        parent_inline: false,
-                                        type_map,
-                                    }).map(|ty| (field.clone(), ty))
-                                )
-                        ),*,]
-                            .into_iter()
-                            .filter_map(|v| v)
-                            .collect::<Vec<_>>(),
-                        result: TResult::to_datatype(DefOpts {
-                            parent_inline: false,
-                            type_map,
-                        }),
-                    }
-                }
-            }
-        }
-    };
-    ( $i2:ident $(, $i:ident)* ) => {
-        impl_typed_command!(impl $i2 $(, $i)* );
-        impl_typed_command!($($i),*);
-    };
-    () => {};
-}
-
-impl_typed_command!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
-
-/// Collects function types into a [`Vec`],
-/// and all downstream types into a [`TypeMap`] instance.
-///
-/// Specifying a `type_map` argument allows a custom [`TypeMap`] to be used.
-///
-/// # Examples
-///
-/// ```rust
-/// use specta::*;
-///
-/// #[specta]
-/// fn some_function(name: String, age: i32) -> bool {
-///     true
-/// }
-///
-/// fn main() {
-///     // `type_defs` is created internally
-///     let (functions, type_defs) = functions::collect_functions![some_function];
-///
-///     let custom_type_defs = TypeMap::default();
-///
-///     // `type_defs` is provided.
-///     // This can be used when integrating multiple specta-enabled libraries.
-///     let (functions, custom_type_defs) = functions::collect_functions![
-///         custom_type_defs; // You can provide a custom map to collect the types into
-///         some_function
-///     ];
-/// }
-/// ````
-#[macro_export]
-macro_rules! collect_functions {
-    ($type_map:ident; $($command:path),* $(,)?) => {{
-        let mut type_map: $crate::TypeMap = $type_map;
-        ([$($crate::fn_datatype!(type_map; $command)),*]
-            .into_iter()
-            .collect::<Vec<_>>(), type_map)
-    }};
-    ($($command:path),* $(,)?) => {{
-        let mut type_map = $crate::TypeMap::default();
-        $crate::functions::collect_functions!(type_map; $($command),*)
-    }};
-}
-
-pub use crate::collect_functions;
diff --git a/src/functions/result.rs b/src/functions/result.rs
deleted file mode 100644
index 281d189..0000000
--- a/src/functions/result.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-mod private {
-    use std::future::Future;
-
-    use crate::{DataType, DefOpts, Type};
-
-    /// Implemented by types that can be returned from a function annotated with
-    /// [`specta`](crate::specta).
-    pub trait SpectaFunctionResult<TMarker> {
-        /// Gets the type of the result as a [`DataType`].
-        fn to_datatype(opts: DefOpts) -> DataType;
-    }
-
-    pub enum SpectaFunctionResultMarker {}
-    impl<T: Type> SpectaFunctionResult<SpectaFunctionResultMarker> for T {
-        fn to_datatype(opts: DefOpts) -> DataType {
-            T::reference(opts, &[]).inner
-        }
-    }
-
-    pub enum SpectaFunctionResultFutureMarker {}
-    impl<F> SpectaFunctionResult<SpectaFunctionResultFutureMarker> for F
-    where
-        F: Future,
-        F::Output: Type,
-    {
-        fn to_datatype(opts: DefOpts) -> DataType {
-            F::Output::reference(opts, &[]).inner
-        }
-    }
-}
-
-pub(crate) use private::SpectaFunctionResult;
diff --git a/src/internal.rs b/src/internal.rs
index e96315a..6799cb0 100644
--- a/src/internal.rs
+++ b/src/internal.rs
@@ -4,11 +4,24 @@
 //!
 //! DO NOT USE THEM! You have been warned!
 
+// Renaming the export so it's less likely to end up in LSP hints
+
 #[cfg(feature = "export")]
-pub use ctor;
+pub use ctor::ctor as __specta_ctor;
+
+pub use paste::paste as __specta_paste;
+
+#[cfg(feature = "functions")]
+mod function_args;
+#[cfg(feature = "functions")]
+mod function_result;
 
+/// Traits used by the `specta` macro to infer type information from functions.
 #[cfg(feature = "functions")]
-pub use specta_macros::fn_datatype;
+pub mod functions {
+    pub use super::function_args::FunctionArg;
+    pub use super::function_result::FunctionOutput;
+}
 
 /// Functions used to construct `crate::datatype` types (they have private fields so can't be constructed directly).
 /// We intentionally keep their fields private so we can modify them without a major version bump.
@@ -27,12 +40,12 @@ pub mod construct {
     }
 
     pub const fn r#struct(
-        name: Cow<'static, str>,
+        name: &'static str,
         generics: Vec<GenericType>,
         fields: StructFields,
     ) -> StructType {
         StructType {
-            name,
+            name: Cow::Borrowed(name),
             generics,
             fields,
         }
@@ -54,13 +67,13 @@ pub mod construct {
     }
 
     pub const fn r#enum(
-        name: Cow<'static, str>,
+        name: &'static str,
         repr: EnumRepr,
         generics: Vec<GenericType>,
         variants: Vec<(Cow<'static, str>, EnumVariant)>,
     ) -> EnumType {
         EnumType {
-            name,
+            name: Cow::Borrowed(name),
             repr,
             generics,
             variants,
@@ -83,18 +96,21 @@ pub mod construct {
     }
 
     pub const fn named_data_type(
-        name: Cow<'static, str>,
+        name: &'static str,
         comments: Vec<Cow<'static, str>>,
-        deprecated: Option<Cow<'static, str>>,
+        deprecated: Option<&'static str>,
         sid: SpectaID,
         impl_location: ImplLocation,
         export: Option<bool>,
         inner: DataType,
     ) -> NamedDataType {
         NamedDataType {
-            name,
+            name: Cow::Borrowed(name),
             comments,
-            deprecated,
+            deprecated: match deprecated {
+                Some(msg) => Some(Cow::Borrowed(msg)),
+                None => None,
+            },
             ext: Some(NamedDataTypeExt {
                 sid,
                 impl_location,
@@ -105,12 +121,12 @@ pub mod construct {
     }
 
     pub const fn data_type_reference(
-        name: Cow<'static, str>,
+        name: &'static str,
         sid: SpectaID,
         generics: Vec<DataType>,
     ) -> DataTypeReference {
         DataTypeReference {
-            name,
+            name: Cow::Borrowed(name),
             sid,
             generics,
         }
@@ -150,4 +166,53 @@ pub mod construct {
 
         SpectaID { type_name, hash }
     }
+
+    // TODO: Macros take in `&'static str` and then `Cow` inside here -> Do for all of them!
+
+    #[cfg(feature = "functions")]
+    pub fn function(export_fn: crate::ExportFn) -> crate::Function {
+        crate::Function { export_fn }
+    }
+
+    #[cfg(feature = "functions")]
+    pub fn function_type(
+        asyncness: bool,
+        name: &'static str,
+        args: Vec<(&'static str, Option<DataType>)>,
+        result: DataType,
+        docs: Vec<Cow<'static, str>>,
+    ) -> FunctionType {
+        FunctionType {
+            asyncness,
+            name: Cow::Borrowed(name),
+            args: args
+                .into_iter()
+                .filter_map(|(name, ty)| ty.map(|ty| (Cow::Borrowed(name), ty)))
+                .collect(),
+            result,
+            docs,
+        }
+    }
+}
+
+/// Internal functions used by the macros for the export feature.
+#[cfg(feature = "export")]
+pub mod export {
+    use std::sync::PoisonError;
+
+    use crate::{export::TYPES, DefOpts, Type};
+
+    // Called within ctor functions to register a type.
+    pub fn register_ty<T: Type>() {
+        let type_map = &mut *TYPES.write().unwrap_or_else(PoisonError::into_inner);
+
+        // We call this for it's side effects on the `type_map`
+        T::reference(
+            DefOpts {
+                parent_inline: false,
+                type_map,
+            },
+            &[],
+        );
+    }
 }
diff --git a/src/internal/function_args.rs b/src/internal/function_args.rs
new file mode 100644
index 0000000..ad8937c
--- /dev/null
+++ b/src/internal/function_args.rs
@@ -0,0 +1,42 @@
+use crate::{DataType, DefOpts, Type};
+
+/// Implemented by types that can be used as an argument in a function annotated with
+/// [`specta`](crate::specta).
+pub trait FunctionArg<TMarker> {
+    /// Gets the type of an argument as a [`DataType`].
+    ///
+    /// Some argument types should be ignored (eg Tauri command State),
+    /// so the value is optional.
+    fn to_datatype(opts: DefOpts) -> Option<DataType>;
+}
+
+pub enum FunctionArgMarker {}
+
+impl<T: Type> FunctionArg<FunctionArgMarker> for T {
+    fn to_datatype(opts: DefOpts) -> Option<DataType> {
+        Some(T::reference(opts, &[]).inner)
+    }
+}
+
+#[cfg(feature = "tauri")]
+const _: () = {
+    pub enum FunctionArgTauriMarker {}
+
+    impl<R: tauri::Runtime> FunctionArg<FunctionArgTauriMarker> for tauri::Window<R> {
+        fn to_datatype(_: DefOpts) -> Option<DataType> {
+            None
+        }
+    }
+
+    impl<'r, T: Send + Sync + 'static> FunctionArg<FunctionArgTauriMarker> for tauri::State<'r, T> {
+        fn to_datatype(_: DefOpts) -> Option<DataType> {
+            None
+        }
+    }
+
+    impl<R: tauri::Runtime> FunctionArg<FunctionArgTauriMarker> for tauri::AppHandle<R> {
+        fn to_datatype(_: DefOpts) -> Option<DataType> {
+            None
+        }
+    }
+};
diff --git a/src/internal/function_result.rs b/src/internal/function_result.rs
new file mode 100644
index 0000000..84012dd
--- /dev/null
+++ b/src/internal/function_result.rs
@@ -0,0 +1,28 @@
+use std::future::Future;
+
+use crate::{DataType, DefOpts, Type};
+
+/// Implemented by types that can be returned from a function annotated with
+/// [`specta`](crate::specta).
+pub trait FunctionOutput<TMarker> {
+    /// Gets the type of the result as a [`DataType`].
+    fn to_datatype(opts: DefOpts) -> DataType;
+}
+
+pub enum FunctionOutputMarker {}
+impl<T: Type> FunctionOutput<FunctionOutputMarker> for T {
+    fn to_datatype(opts: DefOpts) -> DataType {
+        T::reference(opts, &[]).inner
+    }
+}
+
+pub enum FunctionOutputFutureMarker {}
+impl<F> FunctionOutput<FunctionOutputFutureMarker> for F
+where
+    F: Future,
+    F::Output: Type,
+{
+    fn to_datatype(opts: DefOpts) -> DataType {
+        F::Output::reference(opts, &[]).inner
+    }
+}
diff --git a/src/lang/ts/error.rs b/src/lang/ts/error.rs
index cca3f42..9246e4e 100644
--- a/src/lang/ts/error.rs
+++ b/src/lang/ts/error.rs
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 
 use thiserror::Error;
 
-use crate::{ImplLocation, SerdeError};
+use crate::{advanced::SerdeError, ImplLocation};
 
 use super::ExportPath;
 
diff --git a/src/lang/ts/mod.rs b/src/lang/ts/mod.rs
index 223d2ce..4a9d86d 100644
--- a/src/lang/ts/mod.rs
+++ b/src/lang/ts/mod.rs
@@ -14,7 +14,10 @@ pub use export_config::*;
 pub use formatter::*;
 use reserved_terms::*;
 
-use crate::*;
+use crate::{
+    advanced::{detect_duplicate_type_names, is_valid_ty},
+    *,
+};
 
 #[allow(missing_docs)]
 pub type Result<T> = std::result::Result<T, TsExportError>;
diff --git a/src/lib.rs b/src/lib.rs
index 0e4b849..ce62712 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -62,25 +62,25 @@
 #[doc(hidden)]
 pub mod internal;
 
+pub mod advanced;
 /// Types related to working with [`DataType`](crate::DataType). Exposed for advanced users.
 pub mod datatype;
 /// Provides the global type store and a method to export them to other languages.
 #[cfg(feature = "export")]
 #[cfg_attr(docsrs, doc(cfg(feature = "export")))]
 pub mod export;
-/// Support for exporting Rust functions.
 #[cfg(feature = "functions")]
-#[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
-pub mod functions;
+mod function;
 mod lang;
 mod selection;
-mod serde;
 mod static_types;
 /// Contains [`Type`] and everything related to it, including implementations and helper macros
 pub mod r#type;
 
-#[doc(hidden)]
 pub use datatype::*;
+#[cfg(feature = "functions")]
+#[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
+pub use function::*;
 pub use lang::*;
 pub use r#type::*;
 pub use selection::*;
diff --git a/src/type/mod.rs b/src/type/mod.rs
index ec43848..e6b0dc8 100644
--- a/src/type/mod.rs
+++ b/src/type/mod.rs
@@ -3,10 +3,8 @@ use crate::*;
 #[macro_use]
 mod macros;
 mod impls;
-mod post_process;
 mod specta_id;
 
-pub use post_process::*;
 pub use specta_id::*;
 
 use self::reference::Reference;
diff --git a/tests/functions.rs b/tests/functions.rs
index 9b3ccb0..59badfc 100644
--- a/tests/functions.rs
+++ b/tests/functions.rs
@@ -2,7 +2,7 @@
 mod test {
     use std::fmt;
 
-    use specta::{functions, specta, ts::ExportConfig, Type};
+    use specta::{specta, ts::ExportConfig, FunctionType, Type, TypeMap};
 
     /// Multiline
     /// Docs
@@ -84,223 +84,229 @@ mod test {
 
     #[test]
     fn test_trailing_comma() {
-        functions::collect_functions![a];
-        functions::collect_functions![a,];
-        functions::collect_functions![a, b, c];
-        functions::collect_functions![a, b, c,];
+        // functions::collect_functions![a];
+        // functions::collect_functions![a,];
+        // functions::collect_functions![a, b, c];
+        // functions::collect_functions![a, b, c,];
 
-        let (functions, types) = functions::collect_functions![a, b, c, d, e::<i32>, f, g, h, i, k];
+        let function = specta::func!(a);
+        let fn_datatypes = FunctionType::new(function, &mut TypeMap::default());
+
+        let functions = specta::func!(a, b, c, d, e, f, g, h);
+        let fn_datatypes = FunctionType::new(functions, &mut TypeMap::default());
+
+        let fn_datatypes: Vec<FunctionType> = fn_datatypes.into();
     }
 
     #[test]
     fn test_function_exporting() {
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; a);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "a");
-            assert_eq!(def.args.len(), 0);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; b);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "b");
-            assert_eq!(def.args.len(), 1);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "string"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; c);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "c");
-            assert_eq!(def.args.len(), 3);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "string"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[1].1, type_map).unwrap(),
-                "number"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[2].1, type_map).unwrap(),
-                "boolean"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; d);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "d");
-            assert_eq!(def.args.len(), 1);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "string"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "number"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; e::<bool>);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "e");
-            assert_eq!(def.args.len(), 1);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "boolean"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; f);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "f");
-            assert_eq!(def.args.len(), 1);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "string"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "number"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; g);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "g");
-            assert_eq!(def.args.len(), 1);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "string"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; h);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "h");
-            assert_eq!(def.args.len(), 1);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "string"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; i);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "i");
-            assert_eq!(def.args.len(), 0);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "number"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; k);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "k");
-            assert_eq!(def.args.len(), 0);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "string | number"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; l);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "l");
-            assert_eq!(def.args.len(), 2);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "Demo"
-            );
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[1].1, type_map).unwrap(),
-                "[string, number]"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; m);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "m");
-            assert_eq!(def.args.len(), 1);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
-                "Demo"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; async_fn);
-            assert_eq!(def.asyncness, true);
-            assert_eq!(def.name, "async_fn");
-            assert_eq!(def.args.len(), 0);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-        }
-
-        {
-            let mut type_map = &mut specta::TypeMap::default();
-            let def: functions::FunctionDataType = specta::fn_datatype!(type_map; with_docs);
-            assert_eq!(def.asyncness, false);
-            assert_eq!(def.name, "with_docs");
-            assert_eq!(def.args.len(), 0);
-            assert_eq!(
-                specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
-                "null"
-            );
-            assert_eq!(def.docs, vec![" Testing Doc Comment"]);
-        }
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; a);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "a");
+        //     assert_eq!(def.args.len(), 0);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; b);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "b");
+        //     assert_eq!(def.args.len(), 1);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "string"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; c);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "c");
+        //     assert_eq!(def.args.len(), 3);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "string"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[1].1, type_map).unwrap(),
+        //         "number"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[2].1, type_map).unwrap(),
+        //         "boolean"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; d);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "d");
+        //     assert_eq!(def.args.len(), 1);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "string"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "number"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; e::<bool>);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "e");
+        //     assert_eq!(def.args.len(), 1);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "boolean"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; f);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "f");
+        //     assert_eq!(def.args.len(), 1);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "string"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "number"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; g);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "g");
+        //     assert_eq!(def.args.len(), 1);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "string"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; h);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "h");
+        //     assert_eq!(def.args.len(), 1);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "string"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; i);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "i");
+        //     assert_eq!(def.args.len(), 0);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "number"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; k);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "k");
+        //     assert_eq!(def.args.len(), 0);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "string | number"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; l);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "l");
+        //     assert_eq!(def.args.len(), 2);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "Demo"
+        //     );
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[1].1, type_map).unwrap(),
+        //         "[string, number]"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; m);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "m");
+        //     assert_eq!(def.args.len(), 1);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.args[0].1, type_map).unwrap(),
+        //         "Demo"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; async_fn);
+        //     assert_eq!(def.asyncness, true);
+        //     assert_eq!(def.name, "async_fn");
+        //     assert_eq!(def.args.len(), 0);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        // }
+
+        // {
+        //     let mut type_map = &mut specta::TypeMap::default();
+        //     let def: functions::FunctionDataType = specta::fn_datatype!(type_map; with_docs);
+        //     assert_eq!(def.asyncness, false);
+        //     assert_eq!(def.name, "with_docs");
+        //     assert_eq!(def.args.len(), 0);
+        //     assert_eq!(
+        //         specta::ts::datatype(&ExportConfig::default(), &def.result, type_map).unwrap(),
+        //         "null"
+        //     );
+        //     assert_eq!(def.docs, vec![" Testing Doc Comment"]);
+        // }
     }
 }
diff --git a/tests/map_keys.rs b/tests/map_keys.rs
index bd4059a..643aea1 100644
--- a/tests/map_keys.rs
+++ b/tests/map_keys.rs
@@ -1,6 +1,6 @@
 use std::{collections::HashMap, convert::Infallible};
 
-use specta::{Any, SerdeError, Type};
+use specta::{advanced::SerdeError, Any, Type};
 
 use crate::ts::{assert_ts, assert_ts_export};
 
diff --git a/tests/serde/internally_tagged.rs b/tests/serde/internally_tagged.rs
index 5b0c624..1c4080e 100644
--- a/tests/serde/internally_tagged.rs
+++ b/tests/serde/internally_tagged.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use specta::{SerdeError, Type};
+use specta::{advanced::SerdeError, Type};
 
 use crate::ts::assert_ts;