diff --git a/include/boost/type_traits.hpp b/include/boost/type_traits.hpp
index a1c882e03b..7253ab788f 100644
--- a/include/boost/type_traits.hpp
+++ b/include/boost/type_traits.hpp
@@ -94,6 +94,8 @@
 #include <boost/type_traits/is_assignable.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_bounded_array.hpp>
+#include <boost/type_traits/is_unbounded_array.hpp>
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_complex.hpp>
 #include <boost/type_traits/is_compound.hpp>
@@ -160,4 +162,12 @@
 #include <boost/type_traits/promote.hpp>
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_SFINAE_EXPR)
+#include <boost/type_traits/detected.hpp>
+#include <boost/type_traits/is_detected.hpp>
+#include <boost/type_traits/is_detected_convertible.hpp>
+#include <boost/type_traits/is_detected_exact.hpp>
+#include <boost/type_traits/detected_or.hpp>
+#endif
+
 #endif // BOOST_TYPE_TRAITS_HPP
diff --git a/include/boost/type_traits/add_const.hpp b/include/boost/type_traits/add_const.hpp
index 2d60118276..2c41be3587 100644
--- a/include/boost/type_traits/add_const.hpp
+++ b/include/boost/type_traits/add_const.hpp
@@ -27,7 +27,7 @@ namespace boost {
 #   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
 #endif 
 
-   template <class T> struct add_const
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_const
    {
       typedef T const type;
    };
@@ -36,14 +36,14 @@ namespace boost {
 #   pragma warning(pop)
 #endif 
 
-   template <class T> struct add_const<T&>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_const<T&>
    {
       typedef T& type;
    };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_const_t = typename add_const<T>::type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_const_t = typename add_const<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/add_cv.hpp b/include/boost/type_traits/add_cv.hpp
index 425d019bf6..4db00d9a49 100644
--- a/include/boost/type_traits/add_cv.hpp
+++ b/include/boost/type_traits/add_cv.hpp
@@ -11,7 +11,7 @@
 #ifndef BOOST_TT_ADD_CV_HPP_INCLUDED
 #define BOOST_TT_ADD_CV_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
@@ -28,17 +28,17 @@ namespace boost {
 #   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
 #endif 
 
-template <class T> struct add_cv{ typedef T const volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_cv{ typedef T const volatile type; };
 
 #if defined(BOOST_MSVC)
 #   pragma warning(pop)
 #endif 
 
-template <class T> struct add_cv<T&>{ typedef T& type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_cv<T&>{ typedef T& type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_cv_t = typename add_cv<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_cv_t = typename add_cv<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/add_lvalue_reference.hpp b/include/boost/type_traits/add_lvalue_reference.hpp
index 26b74e67ca..e936e6966a 100644
--- a/include/boost/type_traits/add_lvalue_reference.hpp
+++ b/include/boost/type_traits/add_lvalue_reference.hpp
@@ -10,13 +10,13 @@
 
 namespace boost{
 
-template <class T> struct add_lvalue_reference
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_lvalue_reference
 {
    typedef typename boost::add_reference<T>::type type; 
 };
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct add_lvalue_reference<T&&>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_lvalue_reference<T&&>
 {
    typedef T& type;
 };
@@ -24,7 +24,7 @@ template <class T> struct add_lvalue_reference<T&&>
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/add_pointer.hpp b/include/boost/type_traits/add_pointer.hpp
index 80b0703707..d05b1e509a 100644
--- a/include/boost/type_traits/add_pointer.hpp
+++ b/include/boost/type_traits/add_pointer.hpp
@@ -47,7 +47,7 @@ struct add_pointer<T&const volatile>
 
 #else
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct add_pointer
 {
     typedef typename remove_reference<T>::type no_ref_type;
@@ -58,7 +58,7 @@ struct add_pointer
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_pointer_t = typename add_pointer<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_pointer_t = typename add_pointer<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/add_reference.hpp b/include/boost/type_traits/add_reference.hpp
index 33e9bc79be..c3d9a028c8 100644
--- a/include/boost/type_traits/add_reference.hpp
+++ b/include/boost/type_traits/add_reference.hpp
@@ -9,8 +9,7 @@
 #ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
 #define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
 
-#include <boost/detail/workaround.hpp>
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
@@ -21,14 +20,14 @@ namespace detail {
 // references or we get ambiguities from msvc:
 //
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct add_reference_impl
 {
     typedef T& type;
 };
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct add_reference_impl<T&&>
 {
     typedef T&& type;
@@ -37,26 +36,26 @@ struct add_reference_impl<T&&>
 
 } // namespace detail
 
-template <class T> struct add_reference
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_reference
 {
    typedef typename boost::detail::add_reference_impl<T>::type type;
 };
-template <class T> struct add_reference<T&>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_reference<T&>
 {
    typedef T& type;
 };
 
 // these full specialisations are always required:
-template <> struct add_reference<void> { typedef void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<void> { typedef void type; };
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct add_reference<const void> { typedef const void type; };
-template <> struct add_reference<const volatile void> { typedef const volatile void type; };
-template <> struct add_reference<volatile void> { typedef volatile void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<const void> { typedef const void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<const volatile void> { typedef const volatile void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<volatile void> { typedef volatile void type; };
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-template <class T> using add_reference_t = typename add_reference<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_reference_t = typename add_reference<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/add_rvalue_reference.hpp b/include/boost/type_traits/add_rvalue_reference.hpp
index ad64894f77..111d5a37f9 100644
--- a/include/boost/type_traits/add_rvalue_reference.hpp
+++ b/include/boost/type_traits/add_rvalue_reference.hpp
@@ -8,7 +8,7 @@
 #ifndef BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
 #define BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 //----------------------------------------------------------------------------//
 
@@ -53,14 +53,14 @@ namespace type_traits_detail {
 
 }
 
-template <class T> struct add_rvalue_reference
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_rvalue_reference
 {
    typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/add_volatile.hpp b/include/boost/type_traits/add_volatile.hpp
index 253751a578..53a87dd436 100644
--- a/include/boost/type_traits/add_volatile.hpp
+++ b/include/boost/type_traits/add_volatile.hpp
@@ -10,7 +10,7 @@
 #ifndef BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
 #define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
@@ -27,17 +27,17 @@ namespace boost {
 #   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
 #endif 
 
-template <class T> struct add_volatile{ typedef T volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_volatile{ typedef T volatile type; };
 
 #if defined(BOOST_MSVC)
 #   pragma warning(pop)
 #endif 
 
-template <class T> struct add_volatile<T&>{ typedef T& type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_volatile<T&>{ typedef T& type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_volatile_t = typename add_volatile<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_volatile_t = typename add_volatile<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/aligned_storage.hpp b/include/boost/type_traits/aligned_storage.hpp
index 8ad00a20e0..4efba63b0b 100644
--- a/include/boost/type_traits/aligned_storage.hpp
+++ b/include/boost/type_traits/aligned_storage.hpp
@@ -13,10 +13,11 @@
 #ifndef BOOST_TT_ALIGNED_STORAGE_HPP
 #define BOOST_TT_ALIGNED_STORAGE_HPP
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // for std::size_t
+#endif
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
 #include <boost/type_traits/is_pod.hpp>
@@ -26,11 +27,6 @@ namespace boost {
 
 namespace detail { namespace aligned_storage {
 
-BOOST_STATIC_CONSTANT(
-      std::size_t
-    , alignment_of_max_align = ::boost::alignment_of<boost::detail::max_align>::value
-    );
-
 //
 // To be TR1 conforming this must be a POD type:
 //
@@ -68,7 +64,7 @@ struct aligned_storage_imp<0u,alignment_>
 
 }} // namespace detail::aligned_storage
 
-template <
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <
       std::size_t size_
     , std::size_t alignment_ = std::size_t(-1)
 >
@@ -93,7 +89,7 @@ class aligned_storage :
           std::size_t
         , alignment = (
               alignment_ == std::size_t(-1)
-            ? ::boost::detail::aligned_storage::alignment_of_max_align
+            ? ::boost::alignment_of<boost::detail::max_align>::value
             : alignment_
             )
         );
@@ -130,7 +126,7 @@ class aligned_storage :
 // Make sure that is_pod recognises aligned_storage<>::type
 // as a POD (Note that aligned_storage<> itself is not a POD):
 //
-template <std::size_t size_, std::size_t alignment_>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <std::size_t size_, std::size_t alignment_>
 struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> > : public true_type{};
 
 } // namespace boost
diff --git a/include/boost/type_traits/alignment_of.hpp b/include/boost/type_traits/alignment_of.hpp
index baa3f4d95b..03127d235b 100644
--- a/include/boost/type_traits/alignment_of.hpp
+++ b/include/boost/type_traits/alignment_of.hpp
@@ -9,9 +9,11 @@
 #ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
 #define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef>
+#endif
 
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
@@ -25,7 +27,7 @@
 
 namespace boost {
 
-template <typename T> struct alignment_of;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct alignment_of;
 
 // get the alignment of some arbitrary type:
 namespace detail {
@@ -85,25 +87,25 @@ struct alignment_of_impl
 
 } // namespace detail
 
-template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
 
 // references have to be treated specially, assume
 // that a reference is just a special pointer:
-template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
 
 #ifdef BOOST_BORLANDC
 // long double gives an incorrect value of 10 (!)
 // unless we do this...
 struct long_double_wrapper{ long double ld; };
-template<> struct alignment_of<long double> : public alignment_of<long_double_wrapper>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<long double> : public alignment_of<long_double_wrapper>{};
 #endif
 
 // void has to be treated specially:
-template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
-template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
-template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/common_type.hpp b/include/boost/type_traits/common_type.hpp
index 7136d3eed2..da63faf0a7 100644
--- a/include/boost/type_traits/common_type.hpp
+++ b/include/boost/type_traits/common_type.hpp
@@ -9,14 +9,15 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/decay.hpp>
 #include <boost/type_traits/declval.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/is_complete.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_array.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 #if defined(BOOST_NO_CXX11_DECLTYPE)
 #include <boost/type_traits/detail/common_type_impl.hpp>
@@ -33,13 +34,13 @@ namespace boost
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-template<class... T> struct common_type
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class... T> struct common_type
 {
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-template<class... T> using common_type_t = typename common_type<T...>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class... T> using common_type_t = typename common_type<T...>::type;
 
 namespace type_traits_detail
 {
@@ -48,14 +49,14 @@ template<class T1, class T2, class... T> using common_type_fold = common_type_t<
 
 } // namespace type_traits_detail
 
-template<class T1, class T2, class... T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T1, class T2, class... T>
 struct common_type<T1, T2, T...>: type_traits_detail::mp_defer<type_traits_detail::common_type_fold, T1, T2, T...>
 {
 };
 
 #else
 
-template<class T1, class T2, class... T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T1, class T2, class... T>
 struct common_type<T1, T2, T...>: common_type<typename common_type<T1, T2>::type, T...>
 {
 };
@@ -64,7 +65,7 @@ struct common_type<T1, T2, T...>: common_type<typename common_type<T1, T2>::type
 
 #else
 
-template<
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<
     class T1 = void, class T2 = void, class T3 = void,
     class T4 = void, class T5 = void, class T6 = void,
     class T7 = void, class T8 = void, class T9 = void
@@ -77,7 +78,7 @@ struct common_type: common_type<typename common_type<T1, T2>::type, T3, T4, T5,
 
 // one argument
 
-template<class T> struct common_type<T>: boost::decay<T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct common_type<T>: boost::decay<T>
 {
    BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value || ::boost::is_void<T>::value || ::boost::is_array<T>::value, "Arguments to common_type must both be complete types");
 };
@@ -141,7 +142,7 @@ template<class T1, class T2> struct common_type_decay_helper<T1, T2, T1, T2>: co
 
 } // type_traits_detail
 
-template<class T1, class T2> struct common_type<T1, T2>: type_traits_detail::common_type_decay_helper<T1, T2>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T1, class T2> struct common_type<T1, T2>: type_traits_detail::common_type_decay_helper<T1, T2>
 {
    BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T1>::value || ::boost::is_void<T1>::value || ::boost::is_array<T1>::value, "Arguments to common_type must both be complete types");
    BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T2>::value || ::boost::is_void<T2>::value || ::boost::is_array<T2>::value, "Arguments to common_type must both be complete types");
diff --git a/include/boost/type_traits/conditional.hpp b/include/boost/type_traits/conditional.hpp
index ec31d8b0bb..29c4b8b00e 100644
--- a/include/boost/type_traits/conditional.hpp
+++ b/include/boost/type_traits/conditional.hpp
@@ -9,16 +9,16 @@
 #ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED
 #define BOOST_TT_CONDITIONAL_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-template <bool b, class T, class U> struct conditional { typedef T type; };
-template <class T, class U> struct conditional<false, T, U> { typedef U type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool b, class T, class U> struct conditional { typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct conditional<false, T, U> { typedef U type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/conjunction.hpp b/include/boost/type_traits/conjunction.hpp
index aa5440b60e..b385b04a27 100644
--- a/include/boost/type_traits/conjunction.hpp
+++ b/include/boost/type_traits/conjunction.hpp
@@ -18,19 +18,19 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 namespace boost {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class...>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class...>
 struct conjunction
     : true_type { };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct conjunction<T>
     : T { };
 
-template<class T, class... U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class... U>
 struct conjunction<T, U...>
     : conditional<bool(T::value), conjunction<U...>, T>::type { };
 #else
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct conjunction
     : conditional<bool(T::value), U, T>::type { };
 #endif
diff --git a/include/boost/type_traits/copy_cv.hpp b/include/boost/type_traits/copy_cv.hpp
index 2f3dc37adc..12a0687dbf 100644
--- a/include/boost/type_traits/copy_cv.hpp
+++ b/include/boost/type_traits/copy_cv.hpp
@@ -18,7 +18,7 @@
 namespace boost
 {
 
-template<class T, class U> struct copy_cv
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U> struct copy_cv
 {
 private:
 
@@ -31,7 +31,7 @@ template<class T, class U> struct copy_cv
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/copy_cv_ref.hpp b/include/boost/type_traits/copy_cv_ref.hpp
index 59cbc66e99..d9b505b922 100644
--- a/include/boost/type_traits/copy_cv_ref.hpp
+++ b/include/boost/type_traits/copy_cv_ref.hpp
@@ -15,14 +15,14 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct copy_cv_ref {
     typedef typename copy_reference<typename copy_cv<T,
         typename remove_reference<U>::type >::type, U>::type type;
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 using copy_cv_ref_t = typename copy_cv_ref<T, U>::type;
 #endif
 
diff --git a/include/boost/type_traits/copy_reference.hpp b/include/boost/type_traits/copy_reference.hpp
index 005668142a..655e4db4ab 100644
--- a/include/boost/type_traits/copy_reference.hpp
+++ b/include/boost/type_traits/copy_reference.hpp
@@ -17,7 +17,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct copy_reference {
     typedef typename conditional<is_rvalue_reference<U>::value,
         typename add_rvalue_reference<T>::type,
@@ -26,7 +26,7 @@ struct copy_reference {
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 using copy_reference_t = typename copy_reference<T, U>::type;
 #endif
 
diff --git a/include/boost/type_traits/decay.hpp b/include/boost/type_traits/decay.hpp
index 5b28d052fc..208e44c478 100644
--- a/include/boost/type_traits/decay.hpp
+++ b/include/boost/type_traits/decay.hpp
@@ -28,7 +28,7 @@ namespace boost
 
    }
 
-    template< class T >
+    BOOST_TYPE_TRAITS_MODULE_EXPORT template< class T >
     struct decay
     {
     private:
@@ -39,7 +39,7 @@ namespace boost
     
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using decay_t = typename decay<T>::type;
+    BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using decay_t = typename decay<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/declval.hpp b/include/boost/type_traits/declval.hpp
index a050012eb5..c2af2444ca 100644
--- a/include/boost/type_traits/declval.hpp
+++ b/include/boost/type_traits/declval.hpp
@@ -8,7 +8,7 @@
 #ifndef BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED
 #define BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 //----------------------------------------------------------------------------//
 
@@ -36,7 +36,7 @@
 
 namespace boost {
 
-    template <typename T>
+    BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
     typename add_rvalue_reference<T>::type declval() BOOST_NOEXCEPT; // as unevaluated operand
 
 }  // namespace boost
diff --git a/include/boost/type_traits/detail/bool_trait_def.hpp b/include/boost/type_traits/detail/bool_trait_def.hpp
index b6b0677d68..10af53a519 100644
--- a/include/boost/type_traits/detail/bool_trait_def.hpp
+++ b/include/boost/type_traits/detail/bool_trait_def.hpp
@@ -20,7 +20,7 @@
 
 #include <boost/type_traits/detail/template_arity_spec.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 //
 // Unfortunately some libraries have started using this header without
diff --git a/include/boost/type_traits/detail/common_arithmetic_type.hpp b/include/boost/type_traits/detail/common_arithmetic_type.hpp
index 1a76e16d3f..bf58786f09 100644
--- a/include/boost/type_traits/detail/common_arithmetic_type.hpp
+++ b/include/boost/type_traits/detail/common_arithmetic_type.hpp
@@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost
 {
diff --git a/include/boost/type_traits/detail/composite_member_pointer_type.hpp b/include/boost/type_traits/detail/composite_member_pointer_type.hpp
index a747ee4db6..ca6a9dbba7 100644
--- a/include/boost/type_traits/detail/composite_member_pointer_type.hpp
+++ b/include/boost/type_traits/detail/composite_member_pointer_type.hpp
@@ -13,8 +13,10 @@
 #include <boost/type_traits/remove_pointer.hpp>
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/conditional.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
 #include <cstddef>
+#endif
 
 namespace boost
 {
diff --git a/include/boost/type_traits/detail/composite_pointer_type.hpp b/include/boost/type_traits/detail/composite_pointer_type.hpp
index ae21e18ade..de1aca68b0 100644
--- a/include/boost/type_traits/detail/composite_pointer_type.hpp
+++ b/include/boost/type_traits/detail/composite_pointer_type.hpp
@@ -14,8 +14,10 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_base_of.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
 #include <cstddef>
+#endif
 
 namespace boost
 {
diff --git a/include/boost/type_traits/detail/config.hpp b/include/boost/type_traits/detail/config.hpp
index 679ad08bdf..d00f695a77 100644
--- a/include/boost/type_traits/detail/config.hpp
+++ b/include/boost/type_traits/detail/config.hpp
@@ -9,13 +9,18 @@
 #ifndef BOOST_TT_CONFIG_HPP_INCLUDED
 #define BOOST_TT_CONFIG_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #ifndef BOOST_CONFIG_HPP
 #include <boost/config.hpp>
 #endif
 #include <boost/version.hpp>
 #include <boost/config/workaround.hpp>
+#define BOOST_TYPE_TRAITS_MODULE_EXPORT
+#else
+#define BOOST_STATIC_ASSERT(x) static_assert(x)
+#define BOOST_STATIC_ASSERT_MSG(x, msg) static_assert(x, msg)
+#endif
 
-//
 // whenever we have a conversion function with ellipses
 // it needs to be declared __cdecl to suppress compiler
 // warnings from MS and Borland compilers (this *must*
@@ -112,5 +117,3 @@
 #endif
 
 #endif // BOOST_TT_CONFIG_HPP_INCLUDED
-
-
diff --git a/include/boost/type_traits/detail/has_binary_operator.hpp b/include/boost/type_traits/detail/has_binary_operator.hpp
index 7e74705eb3..58d197bed3 100644
--- a/include/boost/type_traits/detail/has_binary_operator.hpp
+++ b/include/boost/type_traits/detail/has_binary_operator.hpp
@@ -6,7 +6,6 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -38,7 +37,9 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/add_reference.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <utility>
+#endif
 
 namespace boost
 {
@@ -70,11 +71,11 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, U, Ret> {};
-   template <class T, class U>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U>
    struct BOOST_TT_TRAIT_NAME<T, U, void> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T, U> {};
-   template <class T, class U>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U>
    struct BOOST_TT_TRAIT_NAME<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T, U> {};
 
 
diff --git a/include/boost/type_traits/detail/has_postfix_operator.hpp b/include/boost/type_traits/detail/has_postfix_operator.hpp
index d900acd3d4..81b8f61b1d 100644
--- a/include/boost/type_traits/detail/has_postfix_operator.hpp
+++ b/include/boost/type_traits/detail/has_postfix_operator.hpp
@@ -6,7 +6,6 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 #if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
@@ -16,7 +15,9 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/add_reference.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <utility>
+#endif
 
 namespace boost
 {
@@ -48,11 +49,11 @@ namespace boost
 
    }
 
-   template <class T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class Ret = boost::binary_op_detail::dont_care>
    struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, Ret> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, void> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T> {};
 
 
diff --git a/include/boost/type_traits/detail/has_prefix_operator.hpp b/include/boost/type_traits/detail/has_prefix_operator.hpp
index 77818c20fb..c5eecf0417 100644
--- a/include/boost/type_traits/detail/has_prefix_operator.hpp
+++ b/include/boost/type_traits/detail/has_prefix_operator.hpp
@@ -6,7 +6,6 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 #if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
@@ -16,7 +15,9 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/add_reference.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <utility>
+#endif
 
 #ifdef BOOST_GCC
 #pragma GCC diagnostic push
@@ -57,11 +58,11 @@ namespace boost
 
    }
 
-   template <class T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class Ret = boost::binary_op_detail::dont_care>
    struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, Ret> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, void> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T> {};
 
 
diff --git a/include/boost/type_traits/detail/is_function_cxx_11.hpp b/include/boost/type_traits/detail/is_function_cxx_11.hpp
index 2dbe1de0ee..d3032ad15b 100644
--- a/include/boost/type_traits/detail/is_function_cxx_11.hpp
+++ b/include/boost/type_traits/detail/is_function_cxx_11.hpp
@@ -15,7 +15,7 @@
 
 namespace boost {
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_function : public false_type {};
 
 #if defined(__cpp_noexcept_function_type) && !defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM)
@@ -33,313 +33,313 @@ namespace boost {
 #endif
    
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
    
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
    
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)&& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)&& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_X64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
    
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
@@ -354,310 +354,310 @@ namespace boost {
 #define BOOST_TT_NOEXCEPT_DECL noexcept
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
diff --git a/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp b/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
index dcc6e2a0a1..d7028b829e 100644
--- a/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
+++ b/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
@@ -14,7 +14,9 @@
 #ifndef BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED
 #define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
+#endif
 
 #if defined(BOOST_TT_PREPROCESSING_MODE)
 //
diff --git a/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp b/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp
index ac3477b38c..40d69c142d 100644
--- a/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp
+++ b/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp
@@ -22,13 +22,13 @@ namespace boost {
 #endif
 
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer : public false_type {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer<T const> : public is_member_function_pointer<T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer<T volatile> : public is_member_function_pointer<T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer<T const volatile> : public is_member_function_pointer<T> {};
 
 #if defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM)
@@ -44,318 +44,318 @@ namespace boost {
 #define BOOST_TT_NOEXCEPT_DECL
 #endif
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (C::*)(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__clrcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
  
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
  
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
@@ -368,318 +368,318 @@ namespace boost {
 #undef BOOST_TT_NOEXCEPT_DECL
 #define BOOST_TT_NOEXCEPT_DECL noexcept
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
diff --git a/include/boost/type_traits/detected.hpp b/include/boost/type_traits/detected.hpp
index 96a38a2e29..2bfe4b8540 100644
--- a/include/boost/type_traits/detected.hpp
+++ b/include/boost/type_traits/detected.hpp
@@ -15,7 +15,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<template<class...> class Op, class... Args>
 using detected_t = typename
     detail::detector<nonesuch, void, Op, Args...>::type;
 
diff --git a/include/boost/type_traits/detected_or.hpp b/include/boost/type_traits/detected_or.hpp
index e79e02a655..28c7b9ae07 100644
--- a/include/boost/type_traits/detected_or.hpp
+++ b/include/boost/type_traits/detected_or.hpp
@@ -14,10 +14,10 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class Default, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Default, template<class...> class Op, class... Args>
 using detected_or = detail::detector<Default, void, Op, Args...>;
 
-template<class Default, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Default, template<class...> class Op, class... Args>
 using detected_or_t = typename detected_or<Default, Op, Args...>::type;
 
 } /* boost */
diff --git a/include/boost/type_traits/disjunction.hpp b/include/boost/type_traits/disjunction.hpp
index dd06991b74..177c7e3182 100644
--- a/include/boost/type_traits/disjunction.hpp
+++ b/include/boost/type_traits/disjunction.hpp
@@ -18,19 +18,19 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 namespace boost {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class...>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class...>
 struct disjunction
     : false_type { };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct disjunction<T>
     : T { };
 
-template<class T, class... U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class... U>
 struct disjunction<T, U...>
     : conditional<bool(T::value), T, disjunction<U...> >::type { };
 #else
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct disjunction
     : conditional<bool(T::value), T, U>::type { };
 #endif
diff --git a/include/boost/type_traits/enable_if.hpp b/include/boost/type_traits/enable_if.hpp
index 3cdc2816f8..2a43a8c404 100644
--- a/include/boost/type_traits/enable_if.hpp
+++ b/include/boost/type_traits/enable_if.hpp
@@ -15,20 +15,20 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_TT_ENABLE_IF_HPP_INCLUDED
 #define BOOST_TT_ENABLE_IF_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-template<bool B, class T = void>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<bool B, class T = void>
 struct enable_if_ {
     typedef T type;
 };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct enable_if_<false, T> { };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<bool B, class T = void>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<bool B, class T = void>
 using enable_if_t = typename enable_if_<B, T>::type;
 #endif
 
diff --git a/include/boost/type_traits/extent.hpp b/include/boost/type_traits/extent.hpp
index 2bf517fc70..c0164d320a 100644
--- a/include/boost/type_traits/extent.hpp
+++ b/include/boost/type_traits/extent.hpp
@@ -10,9 +10,10 @@
 #ifndef BOOST_TT_EXTENT_HPP_INCLUDED
 #define BOOST_TT_EXTENT_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/detail/workaround.hpp>
 
 namespace boost {
 
@@ -128,7 +129,7 @@ struct extent_imp<T const volatile[], 0>
 #endif  // non-CodeGear implementation
 }   // ::boost::detail
 
-template <class T, std::size_t N = 0>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N = 0>
 struct extent
    : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
 {
diff --git a/include/boost/type_traits/floating_point_promotion.hpp b/include/boost/type_traits/floating_point_promotion.hpp
index 9110f24a4e..7e0810a1e5 100644
--- a/include/boost/type_traits/floating_point_promotion.hpp
+++ b/include/boost/type_traits/floating_point_promotion.hpp
@@ -6,19 +6,19 @@
 #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
 #define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-   template<class T> struct floating_point_promotion { typedef T type; };
-   template<> struct floating_point_promotion<float> { typedef double type; };
-   template<> struct floating_point_promotion<float const> { typedef double const type; };
-   template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
-   template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct floating_point_promotion { typedef T type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float> { typedef double type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float const> { typedef double const type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using floating_point_promotion_t = typename floating_point_promotion<T>::type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using floating_point_promotion_t = typename floating_point_promotion<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/function_traits.hpp b/include/boost/type_traits/function_traits.hpp
index 26d7e05c5f..0468cfa93b 100644
--- a/include/boost/type_traits/function_traits.hpp
+++ b/include/boost/type_traits/function_traits.hpp
@@ -9,7 +9,7 @@
 #ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
 #define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_function.hpp>
 #include <boost/type_traits/add_pointer.hpp>
 
@@ -163,7 +163,7 @@ struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
 
 } // end namespace detail
 
-template<typename Function>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<typename Function>
 struct function_traits : 
   public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type>
 {
diff --git a/include/boost/type_traits/has_minus.hpp b/include/boost/type_traits/has_minus.hpp
index fcd5d94779..58c6582359 100644
--- a/include/boost/type_traits/has_minus.hpp
+++ b/include/boost/type_traits/has_minus.hpp
@@ -9,7 +9,6 @@
 #ifndef BOOST_TT_HAS_MINUS_HPP_INCLUDED
 #define BOOST_TT_HAS_MINUS_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -87,7 +86,7 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct has_minus : 
       public boost::binary_op_detail::has_minus_void_ptr_filter<
          T, U, Ret, 
diff --git a/include/boost/type_traits/has_minus_assign.hpp b/include/boost/type_traits/has_minus_assign.hpp
index ea3169e0bd..663a95b1d5 100644
--- a/include/boost/type_traits/has_minus_assign.hpp
+++ b/include/boost/type_traits/has_minus_assign.hpp
@@ -9,7 +9,6 @@
 #ifndef BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -88,7 +87,7 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct has_minus_assign :
       public boost::binary_op_detail::has_minus_assign_void_ptr_filter<
       T, U, Ret,
diff --git a/include/boost/type_traits/has_new_operator.hpp b/include/boost/type_traits/has_new_operator.hpp
index 4def872ddf..f4480b406f 100644
--- a/include/boost/type_traits/has_new_operator.hpp
+++ b/include/boost/type_traits/has_new_operator.hpp
@@ -9,11 +9,16 @@
 #ifndef BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED
 #define BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <new> // std::nothrow_t
 #include <cstddef> // std::size_t
+#include <boost/detail/workaround.hpp>
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
+
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/detail/workaround.hpp>
 
 #if defined(new) 
 #  if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
@@ -136,7 +141,7 @@ namespace detail {
     };
 } // namespace detail
 
-template <class T> struct has_new_operator : public integral_constant<bool, ::boost::detail::has_new_operator_impl<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_new_operator : public integral_constant<bool, ::boost::detail::has_new_operator_impl<T>::value>{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/has_nothrow_assign.hpp b/include/boost/type_traits/has_nothrow_assign.hpp
index 7517fa804b..62bbe21728 100644
--- a/include/boost/type_traits/has_nothrow_assign.hpp
+++ b/include/boost/type_traits/has_nothrow_assign.hpp
@@ -9,12 +9,16 @@
 #ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 
-#if !defined(BOOST_HAS_NOTHROW_ASSIGN) || defined(BOOST_MSVC) || defined(BOOST_INTEL)
+#if (defined(BOOST_MSVC) || defined(BOOST_INTEL) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES))
 #include <boost/type_traits/has_trivial_assign.hpp>
+#endif
+#if !defined(BOOST_HAS_NOTHROW_ASSIGN)
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_const.hpp>
@@ -49,9 +53,9 @@ namespace boost {
 
 #endif
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct has_nothrow_assign : public integral_constant < bool,
-#ifndef BOOST_HAS_NOTHROW_ASSIGN
+#if !defined(BOOST_HAS_NOTHROW_ASSIGN)
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       // Portable C++11 version:
       detail::has_nothrow_assign_imp<T, 
@@ -66,17 +70,17 @@ namespace boost {
 #endif
    > {};
 
-template <class T, std::size_t N> struct has_nothrow_assign <T[N]> : public has_nothrow_assign<T> {};
-template <> struct has_nothrow_assign<void> : public false_type{};
-template <class T> struct has_nothrow_assign<T volatile> : public false_type{};
-template <class T> struct has_nothrow_assign<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_nothrow_assign <T[N]> : public has_nothrow_assign<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_assign<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_assign<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class T> struct has_nothrow_assign<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_assign<T&&> : public false_type{};
 #endif
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_nothrow_assign<void const> : public false_type{};
-template <> struct has_nothrow_assign<void const volatile> : public false_type{};
-template <> struct has_nothrow_assign<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void volatile> : public false_type{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/has_nothrow_constructor.hpp b/include/boost/type_traits/has_nothrow_constructor.hpp
index fa47b1db3c..cd1975f120 100644
--- a/include/boost/type_traits/has_nothrow_constructor.hpp
+++ b/include/boost/type_traits/has_nothrow_constructor.hpp
@@ -9,11 +9,13 @@
 #ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
 #define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
-#ifdef BOOST_HAS_NOTHROW_CONSTRUCTOR
+#if defined(BOOST_HAS_NOTHROW_CONSTRUCTOR)
 
 #if defined(BOOST_MSVC) || defined(BOOST_INTEL)
 #include <boost/type_traits/has_trivial_constructor.hpp>
@@ -24,7 +26,7 @@
 
 namespace boost {
 
-template <class T> struct has_nothrow_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_CONSTRUCTOR(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_CONSTRUCTOR(T)>{};
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT)
 
@@ -43,7 +45,7 @@ namespace boost { namespace detail{
    template <class T, std::size_t N> struct has_nothrow_constructor_imp<T[N], true> : public has_nothrow_constructor_imp<T, true> {};
 }
 
-template <class T> struct has_nothrow_constructor : public detail::has_nothrow_constructor_imp<T, is_default_constructible<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_constructor : public detail::has_nothrow_constructor_imp<T, is_default_constructible<T>::value>{};
 
 #ifdef BOOST_MSVC
 #pragma warning(pop)
@@ -55,18 +57,18 @@ template <class T> struct has_nothrow_constructor : public detail::has_nothrow_c
 
 namespace boost {
 
-template <class T> struct has_nothrow_constructor : public ::boost::has_trivial_constructor<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_constructor : public ::boost::has_trivial_constructor<T> {};
 
 #endif
 
-template<> struct has_nothrow_constructor<void> : public false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void> : public false_type {};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template<> struct has_nothrow_constructor<void const> : public false_type{};
-template<> struct has_nothrow_constructor<void const volatile> : public false_type{};
-template<> struct has_nothrow_constructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void volatile> : public false_type{};
 #endif
 
-template <class T> struct has_nothrow_default_constructor : public has_nothrow_constructor<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_default_constructor : public has_nothrow_constructor<T>{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/has_nothrow_copy.hpp b/include/boost/type_traits/has_nothrow_copy.hpp
index fd9db8d850..2e1dea1428 100644
--- a/include/boost/type_traits/has_nothrow_copy.hpp
+++ b/include/boost/type_traits/has_nothrow_copy.hpp
@@ -12,7 +12,7 @@
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
-#ifdef BOOST_HAS_NOTHROW_COPY
+#if defined(BOOST_HAS_NOTHROW_COPY)
 
 #if defined(BOOST_CLANG) || defined(__GNUC__) || defined(__ghs__) || defined(BOOST_CODEGEARC) || defined(__SUNPRO_CC)
 #include <boost/type_traits/is_volatile.hpp>
@@ -33,7 +33,7 @@
 
 namespace boost {
 
-template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_COPY(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_COPY(T)>{};
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT)
 
@@ -51,7 +51,7 @@ struct has_nothrow_copy_constructor_imp<T, true> : public boost::integral_consta
 
 }
 
-template <class T> struct has_nothrow_copy_constructor : public detail::has_nothrow_copy_constructor_imp<T, boost::is_copy_constructible<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor : public detail::has_nothrow_copy_constructor_imp<T, boost::is_copy_constructible<T>::value>{};
 
 #else
 
@@ -59,23 +59,23 @@ template <class T> struct has_nothrow_copy_constructor : public detail::has_noth
 
 namespace boost{
 
-template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, ::boost::has_trivial_copy<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, ::boost::has_trivial_copy<T>::value>{};
 
 #endif
 
-template <> struct has_nothrow_copy_constructor<void> : public false_type{};
-template <class T> struct has_nothrow_copy_constructor<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor<T volatile> : public false_type{};
 template <class T> struct has_nothrow_copy_constructor<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-template <class T> struct has_nothrow_copy_constructor<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor<T&&> : public false_type{};
 #endif
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_nothrow_copy_constructor<void const> : public false_type{};
-template <> struct has_nothrow_copy_constructor<void volatile> : public false_type{};
-template <> struct has_nothrow_copy_constructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void const volatile> : public false_type{};
 #endif
 
-template <class T> struct has_nothrow_copy : public has_nothrow_copy_constructor<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy : public has_nothrow_copy_constructor<T>{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/has_nothrow_destructor.hpp b/include/boost/type_traits/has_nothrow_destructor.hpp
index 74dd9e7e29..1d4fe4af4b 100644
--- a/include/boost/type_traits/has_nothrow_destructor.hpp
+++ b/include/boost/type_traits/has_nothrow_destructor.hpp
@@ -9,14 +9,16 @@
 #ifndef BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
 #define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
 
-#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(__SUNPRO_CC) && !(defined(BOOST_MSVC) && (_MSC_FULL_VER < 190023506))
 
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_destructible.hpp>
 #include <boost/type_traits/is_complete.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost{
 
@@ -29,22 +31,24 @@ namespace boost{
 
    }
 
-   template <class T> struct has_nothrow_destructor : public detail::has_nothrow_destructor_imp<T, boost::is_destructible<T>::value>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_destructor : public detail::has_nothrow_destructor_imp<T, boost::is_destructible<T>::value>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to has_nothrow_destructor must be complete types");
    };
-   template <class T, std::size_t N> struct has_nothrow_destructor<T[N]> : public has_nothrow_destructor<T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_nothrow_destructor<T[N]> : public has_nothrow_destructor<T>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to has_nothrow_destructor must be complete types");
    };
-   template <class T> struct has_nothrow_destructor<T&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_destructor<T&> : public integral_constant<bool, false>{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-   template <class T> struct has_nothrow_destructor<T&&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_destructor<T&&> : public integral_constant<bool, false>{};
 #endif
-   template <> struct has_nothrow_destructor<void> : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_destructor<void> : public false_type {};
 }
 #else
 
+#include <boost/type_traits/has_trivial_destructor.hpp>
+
 namespace boost {
 
 template <class T> struct has_nothrow_destructor : public ::boost::has_trivial_destructor<T> {};
diff --git a/include/boost/type_traits/has_plus_assign.hpp b/include/boost/type_traits/has_plus_assign.hpp
index 161ca15815..ad79081eaa 100644
--- a/include/boost/type_traits/has_plus_assign.hpp
+++ b/include/boost/type_traits/has_plus_assign.hpp
@@ -9,7 +9,6 @@
 #ifndef BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -91,7 +90,7 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct has_plus_assign : public boost::binary_op_detail:: has_plus_assign_filter_impossible <T, U, Ret, boost::is_arithmetic<typename boost::remove_reference<T>::type>::value && boost::is_pointer<typename remove_reference<U>::type>::value && !boost::is_same<bool, typename boost::remove_cv<typename remove_reference<T>::type>::type>::value> {};
 
 }
diff --git a/include/boost/type_traits/has_trivial_assign.hpp b/include/boost/type_traits/has_trivial_assign.hpp
index 15b917e716..ec56d9e2d2 100644
--- a/include/boost/type_traits/has_trivial_assign.hpp
+++ b/include/boost/type_traits/has_trivial_assign.hpp
@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
@@ -23,7 +25,7 @@
 
 namespace boost {
 
-   template <typename T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
    struct has_trivial_assign : public integral_constant < bool,
 #ifdef BOOST_HAS_TRIVIAL_ASSIGN
       BOOST_HAS_TRIVIAL_ASSIGN(T)
@@ -32,20 +34,20 @@ namespace boost {
 #endif
    > {};
 
-   template<> struct has_trivial_assign<void> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-   template<> struct has_trivial_assign<void const> : public false_type{};
-   template<> struct has_trivial_assign<void const volatile> : public false_type{};
-   template<> struct has_trivial_assign<void volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void const> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void const volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void volatile> : public false_type{};
 #endif
-   template <class T> struct has_trivial_assign<T volatile> : public false_type{};
-   template <class T> struct has_trivial_assign<T&> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_assign<T volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_assign<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-   template <class T> struct has_trivial_assign<T&&> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_assign<T&&> : public false_type{};
 #endif
    // Arrays are not explictly assignable:
-   template <typename T, std::size_t N> struct has_trivial_assign<T[N]> : public false_type{};
-   template <typename T> struct has_trivial_assign<T[]> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct has_trivial_assign<T[N]> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_assign<T[]> : public false_type{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/has_trivial_constructor.hpp b/include/boost/type_traits/has_trivial_constructor.hpp
index 06c137d1de..6fe5650f3f 100644
--- a/include/boost/type_traits/has_trivial_constructor.hpp
+++ b/include/boost/type_traits/has_trivial_constructor.hpp
@@ -36,19 +36,19 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_constructor
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_constructor
 #ifdef BOOST_HAS_TRIVIAL_CONSTRUCTOR
    : public integral_constant <bool, ((::boost::is_pod<T>::value || BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)) BOOST_TT_TRIVIAL_CONSTRUCT_FIX)>{};
 #else
    : public integral_constant <bool, ::boost::is_pod<T>::value>{};
 #endif
 
-template <> struct has_trivial_constructor<void> : public boost::false_type{};
-template <> struct has_trivial_constructor<void const> : public boost::false_type{};
-template <> struct has_trivial_constructor<void const volatile> : public boost::false_type{};
-template <> struct has_trivial_constructor<void volatile> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void const> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void const volatile> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void volatile> : public boost::false_type{};
 
-template <class T> struct has_trivial_default_constructor : public has_trivial_constructor<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_default_constructor : public has_trivial_constructor<T> {};
 
 #undef BOOST_TT_TRIVIAL_CONSTRUCT_FIX
 
diff --git a/include/boost/type_traits/has_trivial_copy.hpp b/include/boost/type_traits/has_trivial_copy.hpp
index fd6ad2d03b..6ead6896cb 100644
--- a/include/boost/type_traits/has_trivial_copy.hpp
+++ b/include/boost/type_traits/has_trivial_copy.hpp
@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/is_pod.hpp>
 #include <boost/type_traits/is_reference.hpp>
@@ -28,7 +30,7 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_copy 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_copy 
 : public integral_constant<bool, 
 #ifdef BOOST_HAS_TRIVIAL_COPY
    BOOST_HAS_TRIVIAL_COPY(T) BOOST_TT_TRIVIAL_CONSTRUCT_FIX
@@ -37,24 +39,24 @@ template <typename T> struct has_trivial_copy
 #endif
 >{};
 // Arrays are not explicitly copyable:
-template <typename T, std::size_t N> struct has_trivial_copy<T[N]> : public false_type{};
-template <typename T> struct has_trivial_copy<T[]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct has_trivial_copy<T[N]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_copy<T[]> : public false_type{};
 // Are volatile types ever trivial?  We don't really know, so assume not:
-template <typename T> struct has_trivial_copy<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_copy<T volatile> : public false_type{};
 
-template <> struct has_trivial_copy<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_copy<void const> : public false_type{};
-template <> struct has_trivial_copy<void volatile> : public false_type{};
-template <> struct has_trivial_copy<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void const volatile> : public false_type{};
 #endif
 
-template <class T> struct has_trivial_copy<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_copy<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-template <class T> struct has_trivial_copy<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_copy<T&&> : public false_type{};
 #endif
 
-template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};
 
 #undef BOOST_TT_TRIVIAL_CONSTRUCT_FIX
 
diff --git a/include/boost/type_traits/has_trivial_destructor.hpp b/include/boost/type_traits/has_trivial_destructor.hpp
index 9a3a61ff97..597ff29184 100644
--- a/include/boost/type_traits/has_trivial_destructor.hpp
+++ b/include/boost/type_traits/has_trivial_destructor.hpp
@@ -27,20 +27,20 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_destructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_DESTRUCTOR(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_destructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_DESTRUCTOR(T)>{};
 #else
 #include <boost/type_traits/is_pod.hpp>
 
 namespace boost{
 
-template <typename T> struct has_trivial_destructor : public integral_constant<bool, ::boost::is_pod<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_destructor : public integral_constant<bool, ::boost::is_pod<T>::value>{};
 #endif
 
-template <> struct has_trivial_destructor<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_destructor<void const> : public false_type{};
-template <> struct has_trivial_destructor<void const volatile> : public false_type{};
-template <> struct has_trivial_destructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void volatile> : public false_type{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/has_trivial_move_assign.hpp b/include/boost/type_traits/has_trivial_move_assign.hpp
index 7b392697f3..13f2352ee3 100644
--- a/include/boost/type_traits/has_trivial_move_assign.hpp
+++ b/include/boost/type_traits/has_trivial_move_assign.hpp
@@ -11,7 +11,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
@@ -43,7 +45,7 @@
 
 namespace boost{
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct has_trivial_move_assign : public integral_constant<bool,
 #ifdef BOOST_HAS_TRIVIAL_MOVE_ASSIGN
    BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T)
@@ -52,19 +54,19 @@ struct has_trivial_move_assign : public integral_constant<bool,
 #endif
    > {};
 
-template <> struct has_trivial_move_assign<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_move_assign<void const> : public false_type{};
-template <> struct has_trivial_move_assign<void const volatile> : public false_type{};
-template <> struct has_trivial_move_assign<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void volatile> : public false_type{};
 #endif
-template <class T> struct has_trivial_move_assign<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_assign<T&> : public false_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct has_trivial_move_assign<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_assign<T&&> : public false_type{};
 #endif
 // Array types are not assignable:
-template <class T, std::size_t N> struct has_trivial_move_assign<T[N]> : public false_type{};
-template <class T> struct has_trivial_move_assign<T[]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_trivial_move_assign<T[N]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_assign<T[]> : public false_type{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/has_trivial_move_constructor.hpp b/include/boost/type_traits/has_trivial_move_constructor.hpp
index ce85dc2d79..a53e7ae178 100644
--- a/include/boost/type_traits/has_trivial_move_constructor.hpp
+++ b/include/boost/type_traits/has_trivial_move_constructor.hpp
@@ -11,7 +11,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
@@ -31,7 +33,7 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_move_constructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_move_constructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)>{};
 
 #else
 
@@ -52,27 +54,27 @@ template <typename T> struct has_trivial_move_constructor : public integral_cons
 
 namespace boost {
 
-template <typename T> struct has_trivial_move_constructor 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_move_constructor 
    : public integral_constant<bool, ::boost::is_pod<T>::value && !::boost::is_volatile<T>::value SOLARIS_EXTRA_CHECK>{};
 
 #undef SOLARIS_EXTRA_CHECK
 
 #endif
 
-template <> struct has_trivial_move_constructor<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_move_constructor<void const> : public false_type{};
-template <> struct has_trivial_move_constructor<void volatile> : public false_type{};
-template <> struct has_trivial_move_constructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void const volatile> : public false_type{};
 #endif
 // What should we do with reference types??? The standard seems to suggest these are trivial, even if the thing they reference is not:
-template <class T> struct has_trivial_move_constructor<T&> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_constructor<T&> : public true_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct has_trivial_move_constructor<T&&> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_constructor<T&&> : public true_type{};
 #endif
 // Arrays can not be explicitly copied:
-template <class T, std::size_t N> struct has_trivial_move_constructor<T[N]> : public false_type{};
-template <class T> struct has_trivial_move_constructor<T[]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_trivial_move_constructor<T[N]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_constructor<T[]> : public false_type{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/has_virtual_destructor.hpp b/include/boost/type_traits/has_virtual_destructor.hpp
index 4b0f38368a..f15a7c3efe 100644
--- a/include/boost/type_traits/has_virtual_destructor.hpp
+++ b/include/boost/type_traits/has_virtual_destructor.hpp
@@ -16,9 +16,9 @@
 namespace boost {
 
 #ifdef BOOST_HAS_VIRTUAL_DESTRUCTOR
-   template <class T> struct has_virtual_destructor : public integral_constant<bool, BOOST_HAS_VIRTUAL_DESTRUCTOR(T)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_virtual_destructor : public integral_constant<bool, BOOST_HAS_VIRTUAL_DESTRUCTOR(T)>{};
 #else
-   template <class T> struct has_virtual_destructor : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_virtual_destructor : public integral_constant<bool, false>{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/integral_constant.hpp b/include/boost/type_traits/integral_constant.hpp
index 2592bcb95d..84adf5d945 100644
--- a/include/boost/type_traits/integral_constant.hpp
+++ b/include/boost/type_traits/integral_constant.hpp
@@ -6,8 +6,7 @@
 #ifndef BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
 #define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) \
@@ -20,9 +19,9 @@
 namespace boost{
    namespace mpl
    {
-      template <bool B> struct bool_;
-      template <class I, I val> struct integral_c;
-      struct integral_c_tag;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool B> struct bool_;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT template <class I, I val> struct integral_c;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT struct integral_c_tag;
    }
 }
 
@@ -30,18 +29,18 @@ namespace boost{
 
 namespace mpl_{
 
-   template <bool B> struct bool_;
-   template <class I, I val> struct integral_c;
-   struct integral_c_tag;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool B> struct bool_;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class I, I val> struct integral_c;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT struct integral_c_tag;
 }
 
 namespace boost
 {
    namespace mpl
    {
-      using ::mpl_::bool_;
-      using ::mpl_::integral_c;
-      using ::mpl_::integral_c_tag;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT using ::mpl_::bool_;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT using ::mpl_::integral_c;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT using ::mpl_::integral_c_tag;
    }
 }
 
@@ -49,7 +48,7 @@ namespace boost
 
 namespace boost{
 
-   template <class T, T val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, T val>
    struct integral_constant
    {
       typedef mpl::integral_c_tag tag;
@@ -66,10 +65,10 @@ namespace boost{
       BOOST_CONSTEXPR operator T()const { return val; }
    };
 
-   template <class T, T val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, T val>
    T const integral_constant<T, val>::value;
       
-   template <bool val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool val>
    struct integral_constant<bool, val>
    {
       typedef mpl::integral_c_tag tag;
@@ -86,11 +85,11 @@ namespace boost{
       BOOST_CONSTEXPR operator bool()const { return val; }
    };
 
-   template <bool val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool val>
    bool const integral_constant<bool, val>::value;
 
-   typedef integral_constant<bool, true> true_type;
-   typedef integral_constant<bool, false> false_type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT typedef integral_constant<bool, true> true_type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT typedef integral_constant<bool, false> false_type;
 
 }
 
diff --git a/include/boost/type_traits/integral_promotion.hpp b/include/boost/type_traits/integral_promotion.hpp
index cc6a41d042..07e56b1a28 100644
--- a/include/boost/type_traits/integral_promotion.hpp
+++ b/include/boost/type_traits/integral_promotion.hpp
@@ -6,7 +6,7 @@
 #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
 #define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_enum.hpp>
diff --git a/include/boost/type_traits/intrinsics.hpp b/include/boost/type_traits/intrinsics.hpp
index 72b6d90ef1..8f0bc400a8 100644
--- a/include/boost/type_traits/intrinsics.hpp
+++ b/include/boost/type_traits/intrinsics.hpp
@@ -10,8 +10,6 @@
 
 #ifndef BOOST_TT_DISABLE_INTRINSICS
 
-#include <boost/config.hpp>
-
 #ifndef BOOST_TT_CONFIG_HPP_INCLUDED
 #include <boost/type_traits/detail/config.hpp>
 #endif
@@ -172,7 +170,9 @@
 // we do not #include those here as it produces cyclic dependencies and
 // can cause the intrinsics to not even be used at all!
 //
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #   include <cstddef>
+#endif
 
 #   if __has_feature(is_union)
 #     define BOOST_IS_UNION(T) __is_union(T)
diff --git a/include/boost/type_traits/is_abstract.hpp b/include/boost/type_traits/is_abstract.hpp
index 781d94a479..7a4fc50674 100644
--- a/include/boost/type_traits/is_abstract.hpp
+++ b/include/boost/type_traits/is_abstract.hpp
@@ -47,12 +47,17 @@
 //  - Dec 2004: Added new config macro BOOST_NO_IS_ABSTRACT which causes the template
 //              to degrade gracefully, rather than trash the compiler (John Maddock).
 //
-
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
+
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #ifndef BOOST_IS_ABSTRACT
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/is_class.hpp>
 #ifdef BOOST_NO_IS_ABSTRACT
@@ -140,9 +145,9 @@ struct is_abstract_imp
 }
 
 #ifndef BOOST_NO_IS_ABSTRACT
-template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};
 #else
-template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_arithmetic.hpp b/include/boost/type_traits/is_arithmetic.hpp
index c23811ebea..691dba69d8 100644
--- a/include/boost/type_traits/is_arithmetic.hpp
+++ b/include/boost/type_traits/is_arithmetic.hpp
@@ -14,7 +14,7 @@
 
 namespace boost {
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_array.hpp b/include/boost/type_traits/is_array.hpp
index 16f6a1b227..eadcd92a7c 100644
--- a/include/boost/type_traits/is_array.hpp
+++ b/include/boost/type_traits/is_array.hpp
@@ -15,24 +15,26 @@
 #define BOOST_TT_IS_ARRAY_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T> struct is_array : public integral_constant<bool, __is_array(T)> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array : public integral_constant<bool, __is_array(T)> {};
 #else
-   template <class T> struct is_array : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array : public false_type {};
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-   template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
-   template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
-   template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
-   template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
-   template <class T> struct is_array<T[]> : public true_type{};
-   template <class T> struct is_array<T const[]> : public true_type{};
-   template <class T> struct is_array<T const volatile[]> : public true_type{};
-   template <class T> struct is_array<T volatile[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T const[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T const volatile[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T volatile[]> : public true_type{};
 #endif
 #endif
 
diff --git a/include/boost/type_traits/is_assignable.hpp b/include/boost/type_traits/is_assignable.hpp
index 6a9474b2fd..de2b802952 100644
--- a/include/boost/type_traits/is_assignable.hpp
+++ b/include/boost/type_traits/is_assignable.hpp
@@ -9,15 +9,17 @@
 #ifndef BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED
 #define BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#include <boost/static_assert.hpp>
+#endif
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_complete.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost{
 
-   template <class T, class U = T> struct is_assignable;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T> struct is_assignable;
 
 }
 
@@ -41,18 +43,18 @@ namespace boost{
 
    }
 
-   template <class T, class U> struct is_assignable : public integral_constant<bool, sizeof(detail::is_assignable_imp::test<T, U>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_assignable : public integral_constant<bool, sizeof(detail::is_assignable_imp::test<T, U>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_assignable must be complete types");
    };
-   template <class T, std::size_t N, class U> struct is_assignable<T[N], U> : public is_assignable<T, U>{};
-   template <class T, std::size_t N, class U> struct is_assignable<T(&)[N], U> : public is_assignable<T&, U>{};
-   template <class T, class U> struct is_assignable<T[], U> : public is_assignable<T, U>{};
-   template <class T, class U> struct is_assignable<T(&)[], U> : public is_assignable<T&, U>{};
-   template <class U> struct is_assignable<void, U> : public integral_constant<bool, false>{};
-   template <class U> struct is_assignable<void const, U> : public integral_constant<bool, false>{};
-   template <class U> struct is_assignable<void volatile, U> : public integral_constant<bool, false>{};
-   template <class U> struct is_assignable<void const volatile, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N, class U> struct is_assignable<T[N], U> : public is_assignable<T, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N, class U> struct is_assignable<T(&)[N], U> : public is_assignable<T&, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_assignable<T[], U> : public is_assignable<T, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_assignable<T(&)[], U> : public is_assignable<T&, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void const, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void volatile, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void const volatile, U> : public integral_constant<bool, false>{};
 
 #else
 
diff --git a/include/boost/type_traits/is_base_and_derived.hpp b/include/boost/type_traits/is_base_and_derived.hpp
index 7973e5af57..a1b191a6aa 100644
--- a/include/boost/type_traits/is_base_and_derived.hpp
+++ b/include/boost/type_traits/is_base_and_derived.hpp
@@ -15,9 +15,11 @@
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
 #endif
+#endif
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/is_same.hpp>
 
@@ -228,15 +230,15 @@ struct is_base_and_derived_impl
 #endif
 } // namespace detail
 
-template <class Base, class Derived> struct is_base_and_derived
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived
    : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};
 
-template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
-template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
-template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
 
 #if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x610))
-template <class Base> struct is_base_and_derived<Base, Base> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base> struct is_base_and_derived<Base, Base> : public true_type{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_base_of.hpp b/include/boost/type_traits/is_base_of.hpp
index 89f2f67980..575502b0ed 100644
--- a/include/boost/type_traits/is_base_of.hpp
+++ b/include/boost/type_traits/is_base_of.hpp
@@ -27,12 +27,12 @@ namespace boost {
       };
    }
 
-   template <class Base, class Derived> struct is_base_of
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of
       : public integral_constant<bool, (::boost::detail::is_base_of_imp<Base, Derived>::value)> {};
 
-   template <class Base, class Derived> struct is_base_of<Base, Derived&> : false_type{};
-   template <class Base, class Derived> struct is_base_of<Base&, Derived&> : false_type{};
-   template <class Base, class Derived> struct is_base_of<Base&, Derived> : false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of<Base, Derived&> : false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of<Base&, Derived&> : false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of<Base&, Derived> : false_type{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/is_bounded_array.hpp b/include/boost/type_traits/is_bounded_array.hpp
index 5aeca6f98e..346bd21906 100644
--- a/include/boost/type_traits/is_bounded_array.hpp
+++ b/include/boost/type_traits/is_bounded_array.hpp
@@ -11,28 +11,30 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 #define BOOST_TT_IS_BOUNDED_ARRAY_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef>
+#endif
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_bounded_array
     : false_type { };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<T[N]>
     : true_type { };
 
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<const T[N]>
     : true_type { };
 
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<volatile T[N]>
     : true_type { };
 
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<const volatile T[N]>
     : true_type { };
 #endif
diff --git a/include/boost/type_traits/is_class.hpp b/include/boost/type_traits/is_class.hpp
index e3a22d2b63..9d86c0960f 100644
--- a/include/boost/type_traits/is_class.hpp
+++ b/include/boost/type_traits/is_class.hpp
@@ -102,11 +102,11 @@ struct is_class_impl
 
 } // namespace detail
 
-template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
 # ifdef __EDG_VERSION__
-template <class T> struct is_class<const T> : public is_class<T>{};
-template <class T> struct is_class<const volatile T> : public is_class<T>{};
-template <class T> struct is_class<volatile T> : public is_class<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class<const T> : public is_class<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class<const volatile T> : public is_class<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class<volatile T> : public is_class<T>{};
 # endif
     
 } // namespace boost
diff --git a/include/boost/type_traits/is_complete.hpp b/include/boost/type_traits/is_complete.hpp
index 08f0e6277a..d2f1ea31d8 100644
--- a/include/boost/type_traits/is_complete.hpp
+++ b/include/boost/type_traits/is_complete.hpp
@@ -14,8 +14,9 @@
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/is_function.hpp>
 #include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/config/workaround.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef>
+#endif
 
 /*
  * CAUTION:
@@ -50,7 +51,7 @@ namespace boost {
       char check_is_complete(...);
    }
 
-   template <class T> struct is_complete
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complete
       : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(boost::detail::check_is_complete<T>(0)) != sizeof(char))> {};
 
 #elif !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
@@ -73,16 +74,16 @@ namespace boost {
 } // namespace detail
 
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_complete : boost::integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || ::boost::detail::is_complete_imp<T>::value>
    {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_complete<T&> : boost::is_complete<T> {};
    
 #else
 
-      template <class T> struct is_complete
-         : public boost::integral_constant<bool, true> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complete
+      : public boost::integral_constant<bool, true> {};
 
 #undef BOOST_TT_HAS_WORKING_IS_COMPLETE
 
diff --git a/include/boost/type_traits/is_complex.hpp b/include/boost/type_traits/is_complex.hpp
index c4554cea08..a95848e185 100644
--- a/include/boost/type_traits/is_complex.hpp
+++ b/include/boost/type_traits/is_complex.hpp
@@ -8,17 +8,19 @@
 #ifndef BOOST_TT_IS_COMPLEX_HPP
 #define BOOST_TT_IS_COMPLEX_HPP
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
 #include <complex>
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
-   template <class T> struct is_complex : public false_type {};
-   template <class T> struct is_complex<const T > : public is_complex<T>{};
-   template <class T> struct is_complex<volatile const T > : public is_complex<T>{};
-   template <class T> struct is_complex<volatile T > : public is_complex<T>{};
-   template <class T> struct is_complex<std::complex<T> > : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<const T > : public is_complex<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<volatile const T > : public is_complex<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<volatile T > : public is_complex<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<std::complex<T> > : public true_type{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/is_compound.hpp b/include/boost/type_traits/is_compound.hpp
index 08f6e1198a..e2c8e51669 100644
--- a/include/boost/type_traits/is_compound.hpp
+++ b/include/boost/type_traits/is_compound.hpp
@@ -14,9 +14,9 @@
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T> struct is_compound : public integral_constant<bool, __is_compound(T)> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_compound : public integral_constant<bool, __is_compound(T)> {};
 #else
-   template <class T> struct is_compound : public integral_constant<bool, ! ::boost::is_fundamental<T>::value> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_compound : public integral_constant<bool, ! ::boost::is_fundamental<T>::value> {};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_const.hpp b/include/boost/type_traits/is_const.hpp
index 256326f803..4da5e4db56 100644
--- a/include/boost/type_traits/is_const.hpp
+++ b/include/boost/type_traits/is_const.hpp
@@ -21,23 +21,25 @@
 #ifndef BOOST_TT_IS_CONST_HPP_INCLUDED
 #define BOOST_TT_IS_CONST_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_const : public integral_constant<bool, __is_const(T)> {};
 
 #else
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_const : public false_type {};
-   template <class T> struct is_const<T const> : public true_type{};
-   template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
-   template <class T> struct is_const<T const[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_const<T const> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_const<T const[]> : public true_type{};
 
 #endif
 
diff --git a/include/boost/type_traits/is_constructible.hpp b/include/boost/type_traits/is_constructible.hpp
index 6969cd63be..ea164e5d82 100644
--- a/include/boost/type_traits/is_constructible.hpp
+++ b/include/boost/type_traits/is_constructible.hpp
@@ -10,7 +10,12 @@
 #define BOOST_TT_IS_CONSTRUCTIBLE_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
 
@@ -19,7 +24,6 @@
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_complete.hpp>
-#include <boost/static_assert.hpp>
 
 #define BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING 1
 
@@ -47,23 +51,23 @@ namespace boost{
 
    }
 
-   template <class T, class ...Args> struct is_constructible : public integral_constant<bool, sizeof(detail::is_constructible_imp::test<T, Args...>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class ...Args> struct is_constructible : public integral_constant<bool, sizeof(detail::is_constructible_imp::test<T, Args...>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
    };
-   template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
    };
-   template <class Ref, class Arg> struct is_constructible<Ref&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
-   template <class Ref, class Arg> struct is_constructible<Ref&&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ref, class Arg> struct is_constructible<Ref&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ref, class Arg> struct is_constructible<Ref&&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
 
-   template <> struct is_constructible<void> : public false_type{};
-   template <> struct is_constructible<void const> : public false_type{};
-   template <> struct is_constructible<void const volatile> : public false_type{};
-   template <> struct is_constructible<void volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void const> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void const volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void volatile> : public false_type{};
 
-   template <class T> struct is_constructible<T> : public is_default_constructible<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_constructible<T> : public is_default_constructible<T>{};
 
 #else
 
diff --git a/include/boost/type_traits/is_convertible.hpp b/include/boost/type_traits/is_convertible.hpp
index f873ef6bfd..df4e5890f5 100644
--- a/include/boost/type_traits/is_convertible.hpp
+++ b/include/boost/type_traits/is_convertible.hpp
@@ -17,11 +17,9 @@
 #include <boost/type_traits/is_complete.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_array.hpp>
-#include <boost/static_assert.hpp>
 #ifndef BOOST_IS_CONVERTIBLE
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/detail/config.hpp>
-#include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/is_void.hpp>
 #if !defined(BOOST_NO_IS_ABSTRACT)
@@ -42,6 +40,10 @@
 #include <boost/type_traits/is_same.hpp>
 #endif // BOOST_IS_CONVERTIBLE
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
+#include <boost/static_assert.hpp>
+#endif
+
 namespace boost {
 
 #ifndef BOOST_IS_CONVERTIBLE
@@ -477,7 +479,7 @@ template <class From> struct is_convertible_impl_dispatch<From, void volatile> :
 
 } // namespace detail
 
-template <class From, class To> 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class From, class To>
 struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value> 
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<To>::value || boost::is_void<To>::value || boost::is_array<To>::value, "Destination argument type to is_convertible must be a complete type");
@@ -486,7 +488,7 @@ struct is_convertible : public integral_constant<bool, ::boost::detail::is_conve
 
 #else
 
-template <class From, class To>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class From, class To>
 struct is_convertible : public integral_constant<bool, BOOST_IS_CONVERTIBLE(From, To)> 
 {
 #if defined(BOOST_MSVC)
diff --git a/include/boost/type_traits/is_copy_assignable.hpp b/include/boost/type_traits/is_copy_assignable.hpp
index ed04927b60..0e1b27e0ea 100644
--- a/include/boost/type_traits/is_copy_assignable.hpp
+++ b/include/boost/type_traits/is_copy_assignable.hpp
@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
 #define BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
+#endif
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/is_noncopyable.hpp>
 
@@ -127,12 +129,12 @@ struct is_copy_assignable_impl {
 
 } // namespace detail
 
-template <class T> struct is_copy_assignable : public integral_constant<bool, ::boost::detail::is_copy_assignable_impl<T>::value>{};
-template <> struct is_copy_assignable<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_copy_assignable : public integral_constant<bool, ::boost::detail::is_copy_assignable_impl<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_copy_assignable<void const> : public false_type{};
-template <> struct is_copy_assignable<void const volatile> : public false_type{};
-template <> struct is_copy_assignable<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void volatile> : public false_type{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_copy_constructible.hpp b/include/boost/type_traits/is_copy_constructible.hpp
index ef97e18eb5..01d3430320 100644
--- a/include/boost/type_traits/is_copy_constructible.hpp
+++ b/include/boost/type_traits/is_copy_constructible.hpp
@@ -9,8 +9,7 @@
 #ifndef BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40900)
 
@@ -20,12 +19,12 @@
 
 namespace boost {
 
-template <class T> struct is_copy_constructible : public boost::is_constructible<T, const T&>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_copy_constructible : public boost::is_constructible<T, const T&>{};
 
-template <> struct is_copy_constructible<void> : public false_type{};
-template <> struct is_copy_constructible<void const> : public false_type{};
-template <> struct is_copy_constructible<void const volatile> : public false_type{};
-template <> struct is_copy_constructible<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void volatile> : public false_type{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/is_default_constructible.hpp b/include/boost/type_traits/is_default_constructible.hpp
index 04c023fe68..fb80003c7f 100644
--- a/include/boost/type_traits/is_default_constructible.hpp
+++ b/include/boost/type_traits/is_default_constructible.hpp
@@ -9,18 +9,22 @@
 #ifndef BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_complete.hpp>
 #include <boost/static_assert.hpp>
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5)) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1800))
+#include <utility> // std::pair
+#endif
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_complete.hpp>
 
 #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
 #include <boost/type_traits/is_abstract.hpp>
 #endif
-#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5)) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1800))
-#include <utility> // std::pair
-#endif
 
 #if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
 
@@ -58,24 +62,24 @@ namespace boost{
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
    };
 #else
-   template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
    };
 #endif
-   template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
-   template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
-   template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};
 #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5))|| (defined(BOOST_MSVC) && (BOOST_MSVC == 1800))
-   template <class T, class U> struct is_default_constructible<std::pair<T,U> > : public integral_constant<bool, is_default_constructible<T>::value && is_default_constructible<U>::value>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_default_constructible<std::pair<T,U> > : public integral_constant<bool, is_default_constructible<T>::value && is_default_constructible<U>::value>{};
 #endif
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-   template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};
 #endif
-   template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
-   template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
-   template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
-   template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
 
 #else
 
diff --git a/include/boost/type_traits/is_destructible.hpp b/include/boost/type_traits/is_destructible.hpp
index c32e758c6c..93bfa97e37 100644
--- a/include/boost/type_traits/is_destructible.hpp
+++ b/include/boost/type_traits/is_destructible.hpp
@@ -9,11 +9,16 @@
 #ifndef BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_complete.hpp>
 #include <boost/static_assert.hpp>
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_complete.hpp>
 
 #if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
 
@@ -34,7 +39,7 @@ namespace boost{
 
    }
 
-   template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_destructible must be complete types");
    };
diff --git a/include/boost/type_traits/is_detected.hpp b/include/boost/type_traits/is_detected.hpp
index 25dfa84890..68ea018655 100644
--- a/include/boost/type_traits/is_detected.hpp
+++ b/include/boost/type_traits/is_detected.hpp
@@ -15,12 +15,12 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<template<class...> class Op, class... Args>
 using is_detected = typename
     detail::detector<nonesuch, void, Op, Args...>::value_t;
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
-template<template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<template<class...> class Op, class... Args>
 constexpr bool is_detected_v = is_detected<Op, Args...>::value;
 #endif
 
diff --git a/include/boost/type_traits/is_detected_convertible.hpp b/include/boost/type_traits/is_detected_convertible.hpp
index 538ba25a38..80015554fd 100644
--- a/include/boost/type_traits/is_detected_convertible.hpp
+++ b/include/boost/type_traits/is_detected_convertible.hpp
@@ -15,11 +15,11 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class To, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class To, template<class...> class Op, class... Args>
 using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
-template<class To, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class To, template<class...> class Op, class... Args>
 constexpr bool is_detected_convertible_v = is_detected_convertible<To, Op,
     Args...>::value;
 #endif
diff --git a/include/boost/type_traits/is_detected_exact.hpp b/include/boost/type_traits/is_detected_exact.hpp
index 34f714c814..0a8069d360 100644
--- a/include/boost/type_traits/is_detected_exact.hpp
+++ b/include/boost/type_traits/is_detected_exact.hpp
@@ -15,11 +15,11 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class Expected, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Expected, template<class...> class Op, class... Args>
 using is_detected_exact = is_same<Expected, detected_t<Op, Args...> >;
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
-template<class Expected, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Expected, template<class...> class Op, class... Args>
 constexpr bool is_detected_exact_v = is_detected_exact<Expected, Op,
     Args...>::value;
 #endif
diff --git a/include/boost/type_traits/is_empty.hpp b/include/boost/type_traits/is_empty.hpp
index ce623e35f4..d836a79e8b 100644
--- a/include/boost/type_traits/is_empty.hpp
+++ b/include/boost/type_traits/is_empty.hpp
@@ -110,7 +110,7 @@ struct is_empty_impl
 
 } // namespace detail
 
-template <class T> struct is_empty : integral_constant<bool, ::boost::detail::is_empty_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_empty : integral_constant<bool, ::boost::detail::is_empty_impl<T>::value> {};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/is_enum.hpp b/include/boost/type_traits/is_enum.hpp
index d23baa1145..ea2c7141df 100644
--- a/include/boost/type_traits/is_enum.hpp
+++ b/include/boost/type_traits/is_enum.hpp
@@ -145,19 +145,19 @@ template <typename T> struct is_enum_impl
 
 } // namespace detail
 
-template <class T> struct is_enum : public integral_constant<bool, ::boost::detail::is_enum_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_enum : public integral_constant<bool, ::boost::detail::is_enum_impl<T>::value> {};
 
 #else // BOOST_BORLANDC
 //
 // buggy is_convertible prevents working
 // implementation of is_enum:
-template <class T> struct is_enum : public integral_constant<bool, false> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_enum : public integral_constant<bool, false> {};
 
 #endif
 
 #else // BOOST_IS_ENUM
 
-template <class T> struct is_enum : public integral_constant<bool, BOOST_IS_ENUM(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_enum : public integral_constant<bool, BOOST_IS_ENUM(T)> {};
 
 #endif
 
diff --git a/include/boost/type_traits/is_final.hpp b/include/boost/type_traits/is_final.hpp
index 21ac93f341..1efdbfc945 100644
--- a/include/boost/type_traits/is_final.hpp
+++ b/include/boost/type_traits/is_final.hpp
@@ -20,9 +20,9 @@
 namespace boost {
 
 #ifdef BOOST_IS_FINAL
-template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(T)> {};
 #else
-template <class T> struct is_final : public integral_constant<bool, false> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_final : public integral_constant<bool, false> {};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_float.hpp b/include/boost/type_traits/is_float.hpp
index 7bf7d1f820..80c1397ab7 100644
--- a/include/boost/type_traits/is_float.hpp
+++ b/include/boost/type_traits/is_float.hpp
@@ -14,7 +14,7 @@
 namespace boost {
 
 //* is a type T a floating-point type described in the standard (3.9.1p8)
-   template <class T> struct is_float : public is_floating_point<T> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_float : public is_floating_point<T> {};
 } // namespace boost
 
 #endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED
diff --git a/include/boost/type_traits/is_floating_point.hpp b/include/boost/type_traits/is_floating_point.hpp
index 196c900cf9..a55640e5d9 100644
--- a/include/boost/type_traits/is_floating_point.hpp
+++ b/include/boost/type_traits/is_floating_point.hpp
@@ -13,16 +13,16 @@
 namespace boost {
 
 //* is a type T a floating-point type described in the standard (3.9.1p8)
-   template <class T> struct is_floating_point : public false_type{};
-   template <class T> struct is_floating_point<const T> : public is_floating_point<T>{};
-   template <class T> struct is_floating_point<volatile const T> : public is_floating_point<T>{};
-   template <class T> struct is_floating_point<volatile T> : public is_floating_point<T>{};
-   template<> struct is_floating_point<float> : public true_type{};
-   template<> struct is_floating_point<double> : public true_type{};
-   template<> struct is_floating_point<long double> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point<const T> : public is_floating_point<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point<volatile const T> : public is_floating_point<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point<volatile T> : public is_floating_point<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<float> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<double> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<long double> : public true_type{};
    
 #if defined(BOOST_HAS_FLOAT128)
-   template<> struct is_floating_point<__float128> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<__float128> : public true_type{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_function.hpp b/include/boost/type_traits/is_function.hpp
index 1518f7b8e1..d2f66f68ee 100644
--- a/include/boost/type_traits/is_function.hpp
+++ b/include/boost/type_traits/is_function.hpp
@@ -12,7 +12,6 @@
 #define BOOST_TT_IS_FUNCTION_HPP_INCLUDED
 
 #include <boost/type_traits/detail/config.hpp>
-#include <boost/config/workaround.hpp>
 
 #ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION
 
diff --git a/include/boost/type_traits/is_fundamental.hpp b/include/boost/type_traits/is_fundamental.hpp
index 5ce28d49e0..24c610c626 100644
--- a/include/boost/type_traits/is_fundamental.hpp
+++ b/include/boost/type_traits/is_fundamental.hpp
@@ -16,9 +16,9 @@ namespace boost {
 
 //* is a type T a fundamental type described in the standard (3.9.1)
 #if defined( BOOST_CODEGEARC )
-template <class T> struct is_fundamental : public integral_constant<bool, __is_fundamental(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_fundamental : public integral_constant<bool, __is_fundamental(T)> {};
 #else
-template <class T> struct is_fundamental : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_void<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_fundamental : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_void<T>::value> {};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_integral.hpp b/include/boost/type_traits/is_integral.hpp
index 6c6e239c31..5e4345d39c 100644
--- a/include/boost/type_traits/is_integral.hpp
+++ b/include/boost/type_traits/is_integral.hpp
@@ -9,77 +9,77 @@
 #ifndef BOOST_TT_IS_INTEGRAL_HPP_INCLUDED
 #define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T>
-   struct is_integral : public integral_constant<bool, __is_integral(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
+struct is_integral : public integral_constant<bool, __is_integral(T)> {};
 #else
 
-template <class T> struct is_integral : public false_type {};
-template <class T> struct is_integral<const T> : public is_integral<T> {};
-template <class T> struct is_integral<volatile const T> : public is_integral<T>{};
-template <class T> struct is_integral<volatile T> : public is_integral<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral : public false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral<const T> : public is_integral<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral<volatile const T> : public is_integral<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral<volatile T> : public is_integral<T>{};
 
 //* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3)
 // as an extension we include long long, as this is likely to be added to the
 // standard at a later date
-template<> struct is_integral<unsigned char> : public true_type {};
-template<> struct is_integral<unsigned short> : public true_type{};
-template<> struct is_integral<unsigned int> : public true_type{};
-template<> struct is_integral<unsigned long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned char> : public true_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned long> : public true_type{};
 
-template<> struct is_integral<signed char> : public true_type{};
-template<> struct is_integral<short> : public true_type{};
-template<> struct is_integral<int> : public true_type{};
-template<> struct is_integral<long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<long> : public true_type{};
 
-template<> struct is_integral<char> : public true_type{};
-template<> struct is_integral<bool> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<bool> : public true_type{};
 
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 // If the following line fails to compile and you're using the Intel
 // compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php,
 // and define BOOST_NO_INTRINSIC_WCHAR_T on the command line.
-template<> struct is_integral<wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<wchar_t> : public true_type{};
 #endif
 
 // Same set of integral types as in boost/type_traits/integral_promotion.hpp.
 // Please, keep in sync. -- Alexander Nasonov
 #if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
     || (defined(BOOST_BORLANDC) && (BOOST_BORLANDC == 0x600) && (_MSC_VER < 1300))
-template<> struct is_integral<unsigned __int8> : public true_type{};
-template<> struct is_integral<unsigned __int16> : public true_type{};
-template<> struct is_integral<unsigned __int32> : public true_type{};
-template<> struct is_integral<__int8> : public true_type{};
-template<> struct is_integral<__int16> : public true_type{};
-template<> struct is_integral<__int32> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int8> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int16> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int32> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int8> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int16> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int32> : public true_type{};
 #ifdef BOOST_BORLANDC
-template<> struct is_integral<unsigned __int64> : public true_type{};
-template<> struct is_integral<__int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int64> : public true_type{};
 #endif
 #endif
 
-# if defined(BOOST_HAS_LONG_LONG)
-template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
-template<> struct is_integral< ::boost::long_long_type> : public true_type{};
+# if !defined(BOOST_NO_LONG_LONG)
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral< ::boost::long_long_type> : public true_type{};
 #elif defined(BOOST_HAS_MS_INT64)
-template<> struct is_integral<unsigned __int64> : public true_type{};
-template<> struct is_integral<__int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int64> : public true_type{};
 #endif
         
 #ifdef BOOST_HAS_INT128
-template<> struct is_integral<boost::int128_type> : public true_type{};
-template<> struct is_integral<boost::uint128_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<boost::int128_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<boost::uint128_type> : public true_type{};
 #endif
 #ifndef BOOST_NO_CXX11_CHAR16_T
-template<> struct is_integral<char16_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<char16_t> : public true_type{};
 #endif
 #ifndef BOOST_NO_CXX11_CHAR32_T
-template<> struct is_integral<char32_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<char32_t> : public true_type{};
 #endif
 
 #endif  // non-CodeGear implementation
diff --git a/include/boost/type_traits/is_list_constructible.hpp b/include/boost/type_traits/is_list_constructible.hpp
index 4a9f84ad3c..2a97c31690 100644
--- a/include/boost/type_traits/is_list_constructible.hpp
+++ b/include/boost/type_traits/is_list_constructible.hpp
@@ -7,12 +7,13 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_complete.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost
 {
@@ -21,7 +22,7 @@ namespace boost
    || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)\
    || BOOST_WORKAROUND(BOOST_GCC, < 40700)
 
-template<class T, class = void, class = void, class = void, class = void, class = void, class = void> struct is_list_constructible: false_type
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class = void, class = void, class = void, class = void, class = void, class = void> struct is_list_constructible: false_type
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_list_constructible must be complete types");
 };
@@ -36,7 +37,7 @@ template<class T, class... A> false_type is_list_constructible_impl( ... );
 
 } // namespace type_traits_detail
 
-template<class T, class... A> struct is_list_constructible: decltype( type_traits_detail::is_list_constructible_impl<T, A...>(0) )
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class... A> struct is_list_constructible: decltype( type_traits_detail::is_list_constructible_impl<T, A...>(0) )
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_list_constructible must be complete types");
 };
diff --git a/include/boost/type_traits/is_lvalue_reference.hpp b/include/boost/type_traits/is_lvalue_reference.hpp
index 553cb9f4e7..339eece133 100644
--- a/include/boost/type_traits/is_lvalue_reference.hpp
+++ b/include/boost/type_traits/is_lvalue_reference.hpp
@@ -26,11 +26,11 @@
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T> struct is_lvalue_reference : public integral_constant<bool, __is_reference(T)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_lvalue_reference : public integral_constant<bool, __is_reference(T)>{};
 #else
 
-   template <class T> struct is_lvalue_reference : public false_type{};
-   template <class T> struct is_lvalue_reference<T&> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_lvalue_reference : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_lvalue_reference<T&> : public true_type{};
 
 #if  defined(BOOST_ILLEGAL_CV_REFERENCES)
 // these are illegal specialisations; cv-qualifies applied to
diff --git a/include/boost/type_traits/is_member_object_pointer.hpp b/include/boost/type_traits/is_member_object_pointer.hpp
index cb7cf14abf..aa467fb69a 100644
--- a/include/boost/type_traits/is_member_object_pointer.hpp
+++ b/include/boost/type_traits/is_member_object_pointer.hpp
@@ -15,7 +15,7 @@
 
 namespace boost {
 
-template <class T> struct is_member_object_pointer 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_member_object_pointer 
    : public integral_constant<bool, 
    ::boost::is_member_pointer<T>::value && !::boost::is_member_function_pointer<T>::value>{};
 
diff --git a/include/boost/type_traits/is_member_pointer.hpp b/include/boost/type_traits/is_member_pointer.hpp
index 2078f15b86..d289b1896b 100644
--- a/include/boost/type_traits/is_member_pointer.hpp
+++ b/include/boost/type_traits/is_member_pointer.hpp
@@ -21,21 +21,21 @@
 #ifndef BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED
 #define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED
 
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-template <class T> struct is_member_pointer : public integral_constant<bool, __is_member_pointer(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_member_pointer : public integral_constant<bool, __is_member_pointer(T)>{};
 #else
-template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{};
-template <class T, class U> struct is_member_pointer<U T::* > : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::* > : public true_type{};
 
 #if !BOOST_WORKAROUND(__MWERKS__,<=0x3003) && !BOOST_WORKAROUND(__IBMCPP__, <=600)
-template <class T, class U> struct is_member_pointer<U T::*const> : public true_type{};
-template <class T, class U> struct is_member_pointer<U T::*const volatile> : public true_type{};
-template <class T, class U> struct is_member_pointer<U T::*volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::*const> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::*const volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::*volatile> : public true_type{};
 #endif
 
 #endif
diff --git a/include/boost/type_traits/is_noncopyable.hpp b/include/boost/type_traits/is_noncopyable.hpp
index 787103ea71..82734b6e12 100644
--- a/include/boost/type_traits/is_noncopyable.hpp
+++ b/include/boost/type_traits/is_noncopyable.hpp
@@ -30,7 +30,7 @@ namespace noncopyable_
 
 #endif // #ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
 
-template<class T> struct is_noncopyable: is_base_and_derived<noncopyable_::base_token, T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct is_noncopyable: is_base_and_derived<noncopyable_::base_token, T>
 {
 };
 
diff --git a/include/boost/type_traits/is_nothrow_move_assignable.hpp b/include/boost/type_traits/is_nothrow_move_assignable.hpp
index c6194de8e8..fdf60342fe 100644
--- a/include/boost/type_traits/is_nothrow_move_assignable.hpp
+++ b/include/boost/type_traits/is_nothrow_move_assignable.hpp
@@ -11,7 +11,7 @@
 #ifndef BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED
 #define BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/has_trivial_move_assign.hpp>
 #include <boost/type_traits/has_nothrow_assign.hpp>
 #include <boost/type_traits/is_array.hpp>
@@ -19,23 +19,25 @@
 #include <boost/type_traits/enable_if.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_complete.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost {
 
 #ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_assignable : public integral_constant<bool, BOOST_IS_NOTHROW_MOVE_ASSIGN(T)>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_assignable must be complete types");
 };
-template <class T> struct is_nothrow_move_assignable<T const> : public false_type{};
-template <class T> struct is_nothrow_move_assignable<T volatile> : public false_type{};
-template <class T> struct is_nothrow_move_assignable<T const volatile> : public false_type{};
-template <class T> struct is_nothrow_move_assignable<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-template <class T> struct is_nothrow_move_assignable<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&&> : public false_type{};
 #endif
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
@@ -54,23 +56,23 @@ struct false_or_cpp11_noexcept_move_assignable <
 
 }
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_assignable : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_assignable<T>::value>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_assignable must be complete types");
 };
 
-template <class T> struct is_nothrow_move_assignable<T const> : public ::boost::false_type {};
-template <class T> struct is_nothrow_move_assignable<T const volatile> : public ::boost::false_type{};
-template <class T> struct is_nothrow_move_assignable<T volatile> : public ::boost::false_type{};
-template <class T> struct is_nothrow_move_assignable<T&> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const> : public ::boost::false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const volatile> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T volatile> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&> : public ::boost::false_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct is_nothrow_move_assignable<T&&> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&&> : public ::boost::false_type{};
 #endif
 
 #else
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_assignable : public integral_constant<bool,
    (::boost::has_trivial_move_assign<T>::value || ::boost::has_nothrow_assign<T>::value) &&  ! ::boost::is_array<T>::value>
 {
@@ -80,11 +82,11 @@ struct is_nothrow_move_assignable : public integral_constant<bool,
 #endif
 
 
-template <> struct is_nothrow_move_assignable<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_nothrow_move_assignable<void const> : public false_type{};
-template <> struct is_nothrow_move_assignable<void const volatile> : public false_type{};
-template <> struct is_nothrow_move_assignable<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void volatile> : public false_type{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_nothrow_move_constructible.hpp b/include/boost/type_traits/is_nothrow_move_constructible.hpp
index 60c2994d05..87cb243c11 100644
--- a/include/boost/type_traits/is_nothrow_move_constructible.hpp
+++ b/include/boost/type_traits/is_nothrow_move_constructible.hpp
@@ -11,26 +11,27 @@
 #ifndef BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#endif
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/is_complete.hpp>
-#include <boost/static_assert.hpp>
 
 #ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT
 
 namespace boost {
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_constructible : public integral_constant<bool, BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T)>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_constructible must be complete types");
 };
 
-template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
-template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
 
@@ -51,16 +52,16 @@ struct false_or_cpp11_noexcept_move_constructible <
 
 }
 
-template <class T> struct is_nothrow_move_constructible
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible
    : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_constructible must be complete types");
 };
 
-template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
-template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
-template <class T, std::size_t N> struct is_nothrow_move_constructible<T[N]> : public ::boost::false_type{};
-template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_nothrow_move_constructible<T[N]> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::false_type{};
 
 #else
 
@@ -70,7 +71,7 @@ template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::f
 
 namespace boost{
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_constructible
    : public integral_constant<bool,
    (::boost::has_trivial_move_constructor<T>::value || ::boost::has_nothrow_copy<T>::value) && !::boost::is_array<T>::value>
@@ -80,16 +81,16 @@ struct is_nothrow_move_constructible
 
 #endif
 
-template <> struct is_nothrow_move_constructible<void> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void> : false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_nothrow_move_constructible<void const> : false_type{};
-template <> struct is_nothrow_move_constructible<void volatile> : false_type{};
-template <> struct is_nothrow_move_constructible<void const volatile> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void const> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void volatile> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void const volatile> : false_type{};
 #endif
 // References are always trivially constructible, even if the thing they reference is not:
-template <class T> struct is_nothrow_move_constructible<T&> : public ::boost::true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<T&> : public ::boost::true_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct is_nothrow_move_constructible<T&&> : public ::boost::true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<T&&> : public ::boost::true_type{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_nothrow_swappable.hpp b/include/boost/type_traits/is_nothrow_swappable.hpp
index 10ad9239a9..13a67be657 100644
--- a/include/boost/type_traits/is_nothrow_swappable.hpp
+++ b/include/boost/type_traits/is_nothrow_swappable.hpp
@@ -7,8 +7,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if defined(BOOST_NO_SFINAE_EXPR) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DECLTYPE) \
    || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
@@ -19,18 +18,21 @@
 
 namespace boost
 {
-template <class T> struct is_nothrow_swappable : boost::integral_constant<bool,
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_swappable : boost::integral_constant<bool,
     boost::is_scalar<T>::value && !boost::is_const<T>::value> {};
 
-template <class T, class U> struct is_nothrow_swappable_with : false_type {};
-template <class T> struct is_nothrow_swappable_with<T, T> : is_nothrow_swappable<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_nothrow_swappable_with : false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_swappable_with<T, T> : is_nothrow_swappable<T> {};
 }
 
 #else
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
+#include <utility>
+#endif
+
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <algorithm>
 
 namespace boost
 {
@@ -56,7 +58,7 @@ template<class T, class U> struct is_nothrow_swappable_with: type_traits_swappab
 {
 };
 
-template<class T> struct is_nothrow_swappable: type_traits_swappable_detail::is_nothrow_swappable_helper<T>::type
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct is_nothrow_swappable: type_traits_swappable_detail::is_nothrow_swappable_helper<T>::type
 {
 };
 
diff --git a/include/boost/type_traits/is_object.hpp b/include/boost/type_traits/is_object.hpp
index fc9d2f25d3..e1e6140bee 100644
--- a/include/boost/type_traits/is_object.hpp
+++ b/include/boost/type_traits/is_object.hpp
@@ -9,14 +9,14 @@
 #ifndef BOOST_TT_IS_OBJECT_HPP_INCLUDED
 #define BOOST_TT_IS_OBJECT_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_reference.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_function.hpp>
 
 namespace boost {
 
-template <class T> struct is_object
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_object
    : public 
       integral_constant<
          bool, 
diff --git a/include/boost/type_traits/is_pod.hpp b/include/boost/type_traits/is_pod.hpp
index 9bd196257a..4342d4ed1d 100644
--- a/include/boost/type_traits/is_pod.hpp
+++ b/include/boost/type_traits/is_pod.hpp
@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_IS_POD_HPP_INCLUDED
 #define BOOST_TT_IS_POD_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_scalar.hpp>
@@ -19,8 +21,6 @@
 #include <boost/type_traits/is_function.hpp>
 #endif
 
-#include <cstddef>
-
 #ifndef BOOST_IS_POD
 #define BOOST_INTERNAL_IS_POD(T) false
 #else
@@ -30,27 +30,27 @@
 namespace boost {
 
 // forward declaration, needed by 'is_pod_array_helper' template below
-template< typename T > struct is_POD;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template< typename T > struct is_POD;
 
-template <typename T> struct is_pod
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct is_pod
 : public integral_constant<bool, ::boost::is_scalar<T>::value || ::boost::is_void<T>::value || BOOST_INTERNAL_IS_POD(T)>
 {};
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template <typename T, std::size_t sz> struct is_pod<T[sz]> : public is_pod<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t sz> struct is_pod<T[sz]> : public is_pod<T>{};
 #endif
 
 
 // the following help compilers without partial specialization support:
-template<> struct is_pod<void> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void> : public true_type{};
 
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template<> struct is_pod<void const> : public true_type{};
-template<> struct is_pod<void const volatile> : public true_type{};
-template<> struct is_pod<void volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void const> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void const volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void volatile> : public true_type{};
 #endif
 
-template<class T> struct is_POD : public is_pod<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct is_POD : public is_pod<T>{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/is_polymorphic.hpp b/include/boost/type_traits/is_polymorphic.hpp
index 722d8b46b2..005763bbd0 100644
--- a/include/boost/type_traits/is_polymorphic.hpp
+++ b/include/boost/type_traits/is_polymorphic.hpp
@@ -13,7 +13,9 @@
 #ifndef BOOST_IS_POLYMORPHIC
 #include <boost/type_traits/is_class.hpp>
 #endif
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/detail/workaround.hpp>
+#endif
 
 #if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700)
 #pragma warning(push)
@@ -105,11 +107,11 @@ struct is_polymorphic_imp
 
 } // namespace detail
 
-template <class T> struct is_polymorphic : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_polymorphic : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
 
 #else // BOOST_IS_POLYMORPHIC
 
-template <class T> struct is_polymorphic : public integral_constant<bool, BOOST_IS_POLYMORPHIC(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_polymorphic : public integral_constant<bool, BOOST_IS_POLYMORPHIC(T)> {};
 
 #endif
 
diff --git a/include/boost/type_traits/is_reference.hpp b/include/boost/type_traits/is_reference.hpp
index 85f0a63204..0a283f613c 100644
--- a/include/boost/type_traits/is_reference.hpp
+++ b/include/boost/type_traits/is_reference.hpp
@@ -17,7 +17,7 @@
 
 namespace boost {
 
-template <class T> struct is_reference 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_reference 
    : public 
    integral_constant<
       bool, 
diff --git a/include/boost/type_traits/is_rvalue_reference.hpp b/include/boost/type_traits/is_rvalue_reference.hpp
index 37d33c95a4..c0bacf12af 100644
--- a/include/boost/type_traits/is_rvalue_reference.hpp
+++ b/include/boost/type_traits/is_rvalue_reference.hpp
@@ -9,14 +9,13 @@
 #ifndef BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED
 #define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
-template <class T> struct is_rvalue_reference : public false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_rvalue_reference : public false_type {};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct is_rvalue_reference<T&&> : public true_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_rvalue_reference<T&&> : public true_type {};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/is_same.hpp b/include/boost/type_traits/is_same.hpp
index 9a9ec7e632..e3af3eeeee 100644
--- a/include/boost/type_traits/is_same.hpp
+++ b/include/boost/type_traits/is_same.hpp
@@ -26,8 +26,8 @@
 namespace boost {
 
 
-   template <class T, class U> struct is_same : public false_type {};
-   template <class T> struct is_same<T,T> : public true_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_same : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_same<T,T> : public true_type {};
 #if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600)
 // without this, Borland's compiler gives the wrong answer for
 // references to arrays:
diff --git a/include/boost/type_traits/is_scalar.hpp b/include/boost/type_traits/is_scalar.hpp
index 3031440596..70064ed73f 100644
--- a/include/boost/type_traits/is_scalar.hpp
+++ b/include/boost/type_traits/is_scalar.hpp
@@ -13,11 +13,10 @@
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_pointer.hpp>
-#include <boost/config.hpp>
 
 namespace boost {
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct is_scalar
    : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_enum<T>::value || ::boost::is_pointer<T>::value || ::boost::is_member_pointer<T>::value>
 {};
diff --git a/include/boost/type_traits/is_scoped_enum.hpp b/include/boost/type_traits/is_scoped_enum.hpp
index 7566859fbc..dd0005bf4f 100644
--- a/include/boost/type_traits/is_scoped_enum.hpp
+++ b/include/boost/type_traits/is_scoped_enum.hpp
@@ -17,7 +17,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_scoped_enum
     : conjunction<is_enum<T>, negation<is_convertible<T, int> > >::type { };
 
diff --git a/include/boost/type_traits/is_signed.hpp b/include/boost/type_traits/is_signed.hpp
index 4d50bf8c6f..4ea3510375 100644
--- a/include/boost/type_traits/is_signed.hpp
+++ b/include/boost/type_traits/is_signed.hpp
@@ -13,7 +13,9 @@
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <climits>
+#endif
 
 namespace boost {
 
@@ -76,86 +78,86 @@ struct is_signed_impl
 
 }
 
-template <class T> struct is_signed : public integral_constant<bool, boost::detail::is_signed_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_signed : public integral_constant<bool, boost::detail::is_signed_impl<T>::value> {};
 
 #else
 
-template <class T> struct is_signed : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_signed : public false_type{};
 
 #endif
 
 #else //defined( BOOST_CODEGEARC )
-   template <class T> struct is_signed : public integral_constant<bool, __is_signed(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_signed : public integral_constant<bool, __is_signed(T)>{};
 #endif
 
-template <> struct is_signed<signed char> : public true_type{};
-template <> struct is_signed<const signed char> : public true_type{};
-template <> struct is_signed<volatile signed char> : public true_type{};
-template <> struct is_signed<const volatile signed char> : public true_type{};
-template <> struct is_signed<short> : public true_type{};
-template <> struct is_signed<const short> : public true_type{};
-template <> struct is_signed<volatile short> : public true_type{};
-template <> struct is_signed<const volatile short> : public true_type{};
-template <> struct is_signed<int> : public true_type{};
-template <> struct is_signed<const int> : public true_type{};
-template <> struct is_signed<volatile int> : public true_type{};
-template <> struct is_signed<const volatile int> : public true_type{};
-template <> struct is_signed<long> : public true_type{};
-template <> struct is_signed<const long> : public true_type{};
-template <> struct is_signed<volatile long> : public true_type{};
-template <> struct is_signed<const volatile long> : public true_type{};
-
-template <> struct is_signed<unsigned char> : public false_type{};
-template <> struct is_signed<const unsigned char> : public false_type{};
-template <> struct is_signed<volatile unsigned char> : public false_type{};
-template <> struct is_signed<const volatile unsigned char> : public false_type{};
-template <> struct is_signed<unsigned short> : public false_type{};
-template <> struct is_signed<const unsigned short> : public false_type{};
-template <> struct is_signed<volatile unsigned short> : public false_type{};
-template <> struct is_signed<const volatile unsigned short> : public false_type{};
-template <> struct is_signed<unsigned int> : public false_type{};
-template <> struct is_signed<const unsigned int> : public false_type{};
-template <> struct is_signed<volatile unsigned int> : public false_type{};
-template <> struct is_signed<const volatile unsigned int> : public false_type{};
-template <> struct is_signed<unsigned long> : public false_type{};
-template <> struct is_signed<const unsigned long> : public false_type{};
-template <> struct is_signed<volatile unsigned long> : public false_type{};
-template <> struct is_signed<const volatile unsigned long> : public false_type{};
-#ifdef BOOST_HAS_LONG_LONG
-template <> struct is_signed< ::boost::long_long_type> : public true_type{};
-template <> struct is_signed<const ::boost::long_long_type> : public true_type{};
-template <> struct is_signed<volatile ::boost::long_long_type> : public true_type{};
-template <> struct is_signed<const volatile ::boost::long_long_type> : public true_type{};
-
-template <> struct is_signed< ::boost::ulong_long_type> : public false_type{};
-template <> struct is_signed<const ::boost::ulong_long_type> : public false_type{};
-template <> struct is_signed<volatile ::boost::ulong_long_type> : public false_type{};
-template <> struct is_signed<const volatile ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile long> : public true_type{};
+
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned long> : public false_type{};
+#ifndef BOOST_NO_LONG_LONG
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed< ::boost::long_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const ::boost::long_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile ::boost::long_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile ::boost::long_long_type> : public true_type{};
+
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed< ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile ::boost::ulong_long_type> : public false_type{};
 #endif
 #if defined(CHAR_MIN) 
 #if CHAR_MIN != 0
-template <> struct is_signed<char> : public true_type{};
-template <> struct is_signed<const char> : public true_type{};
-template <> struct is_signed<volatile char> : public true_type{};
-template <> struct is_signed<const volatile char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile char> : public true_type{};
 #else
-template <> struct is_signed<char> : public false_type{};
-template <> struct is_signed<const char> : public false_type{};
-template <> struct is_signed<volatile char> : public false_type{};
-template <> struct is_signed<const volatile char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile char> : public false_type{};
 #endif
 #endif
 #if defined(WCHAR_MIN) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
 #if WCHAR_MIN != 0
-template <> struct is_signed<wchar_t> : public true_type{};
-template <> struct is_signed<const wchar_t> : public true_type{};
-template <> struct is_signed<volatile wchar_t> : public true_type{};
-template <> struct is_signed<const volatile wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile wchar_t> : public true_type{};
 #else
-template <> struct is_signed<wchar_t> : public false_type{};
-template <> struct is_signed<const wchar_t> : public false_type{};
-template <> struct is_signed<volatile wchar_t> : public false_type{};
-template <> struct is_signed<const volatile wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile wchar_t> : public false_type{};
 #endif
 #endif
 } // namespace boost
diff --git a/include/boost/type_traits/is_stateless.hpp b/include/boost/type_traits/is_stateless.hpp
index f9266da5b8..4b775b5788 100644
--- a/include/boost/type_traits/is_stateless.hpp
+++ b/include/boost/type_traits/is_stateless.hpp
@@ -14,11 +14,11 @@
 #include <boost/type_traits/has_trivial_destructor.hpp>
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_empty.hpp>
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct is_stateless
  : public integral_constant<bool,  
       (::boost::has_trivial_constructor<T>::value
diff --git a/include/boost/type_traits/is_trivially_copyable.hpp b/include/boost/type_traits/is_trivially_copyable.hpp
index a62668aaef..d3783d7c6f 100644
--- a/include/boost/type_traits/is_trivially_copyable.hpp
+++ b/include/boost/type_traits/is_trivially_copyable.hpp
@@ -18,7 +18,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_trivially_copyable
     : integral_constant<bool, has_trivial_copy<T>::value &&
         has_trivial_assign<T>::value &&
diff --git a/include/boost/type_traits/is_unbounded_array.hpp b/include/boost/type_traits/is_unbounded_array.hpp
index 1bacfdca1d..b683dd8f36 100644
--- a/include/boost/type_traits/is_unbounded_array.hpp
+++ b/include/boost/type_traits/is_unbounded_array.hpp
@@ -14,24 +14,24 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_unbounded_array
     : false_type { };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_unbounded_array<T[]>
     : true_type { };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_unbounded_array<const T[]>
     : true_type { };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_unbounded_array<volatile T[]>
     : true_type { };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_unbounded_array<const volatile T[]>
     : true_type { };
 #endif
diff --git a/include/boost/type_traits/is_union.hpp b/include/boost/type_traits/is_union.hpp
index c5e1a96019..21e24baded 100644
--- a/include/boost/type_traits/is_union.hpp
+++ b/include/boost/type_traits/is_union.hpp
@@ -17,14 +17,14 @@
 namespace boost {
 
 #ifdef BOOST_IS_UNION
-template <class T> struct is_union : public integral_constant<bool, BOOST_IS_UNION(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_union : public integral_constant<bool, BOOST_IS_UNION(T)> {};
 #else
-template <class T> struct is_union : public integral_constant<bool, false> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_union : public integral_constant<bool, false> {};
 #endif
 
-template <class T> struct is_union<T const> : public is_union<T>{};
-template <class T> struct is_union<T volatile const> : public is_union<T>{};
-template <class T> struct is_union<T volatile> : public is_union<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_union<T const> : public is_union<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_union<T volatile const> : public is_union<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_union<T volatile> : public is_union<T>{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/is_unscoped_enum.hpp b/include/boost/type_traits/is_unscoped_enum.hpp
index 99f9acb976..28d7152f3b 100644
--- a/include/boost/type_traits/is_unscoped_enum.hpp
+++ b/include/boost/type_traits/is_unscoped_enum.hpp
@@ -16,7 +16,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_unscoped_enum
     : conjunction<is_enum<T>, is_convertible<T, int> >::type { };
 
diff --git a/include/boost/type_traits/is_unsigned.hpp b/include/boost/type_traits/is_unsigned.hpp
index 38b916296d..3a3bb61c16 100644
--- a/include/boost/type_traits/is_unsigned.hpp
+++ b/include/boost/type_traits/is_unsigned.hpp
@@ -14,7 +14,9 @@
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <climits>
+#endif
 
 namespace boost {
 
@@ -65,7 +67,7 @@ struct is_unsigned_select_helper<false>
    };
 };
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_unsigned
 {
    typedef ::boost::detail::is_unsigned_select_helper< ::boost::is_integral<T>::value || ::boost::is_enum<T>::value > selector;
@@ -76,7 +78,7 @@ struct is_unsigned
 
 } // namespace detail
 
-template <class T> struct is_unsigned : public integral_constant<bool, boost::detail::is_unsigned<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_unsigned : public integral_constant<bool, boost::detail::is_unsigned<T>::value> {};
 
 #else
 
@@ -85,77 +87,77 @@ template <class T> struct is_unsigned : public false_type{};
 #endif
 
 #else // defined( BOOST_CODEGEARC )
-template <class T> struct is_unsigned : public integral_constant<bool, __is_unsigned(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_unsigned : public integral_constant<bool, __is_unsigned(T)> {};
 #endif
 
-template <> struct is_unsigned<unsigned char> : public true_type{};
-template <> struct is_unsigned<const unsigned char> : public true_type{};
-template <> struct is_unsigned<volatile unsigned char> : public true_type{};
-template <> struct is_unsigned<const volatile unsigned char> : public true_type{};
-template <> struct is_unsigned<unsigned short> : public true_type{};
-template <> struct is_unsigned<const unsigned short> : public true_type{};
-template <> struct is_unsigned<volatile unsigned short> : public true_type{};
-template <> struct is_unsigned<const volatile unsigned short> : public true_type{};
-template <> struct is_unsigned<unsigned int> : public true_type{};
-template <> struct is_unsigned<const unsigned int> : public true_type{};
-template <> struct is_unsigned<volatile unsigned int> : public true_type{};
-template <> struct is_unsigned<const volatile unsigned int> : public true_type{};
-template <> struct is_unsigned<unsigned long> : public true_type{};
-template <> struct is_unsigned<const unsigned long> : public true_type{};
-template <> struct is_unsigned<volatile unsigned long> : public true_type{};
-template <> struct is_unsigned<const volatile unsigned long> : public true_type{};
-
-template <> struct is_unsigned<signed char> : public false_type{};
-template <> struct is_unsigned<const signed char> : public false_type{};
-template <> struct is_unsigned<volatile signed char> : public false_type{};
-template <> struct is_unsigned<const volatile signed char> : public false_type{};
-template <> struct is_unsigned< short> : public false_type{};
-template <> struct is_unsigned<const  short> : public false_type{};
-template <> struct is_unsigned<volatile  short> : public false_type{};
-template <> struct is_unsigned<const volatile  short> : public false_type{};
-template <> struct is_unsigned< int> : public false_type{};
-template <> struct is_unsigned<const  int> : public false_type{};
-template <> struct is_unsigned<volatile  int> : public false_type{};
-template <> struct is_unsigned<const volatile  int> : public false_type{};
-template <> struct is_unsigned< long> : public false_type{};
-template <> struct is_unsigned<const  long> : public false_type{};
-template <> struct is_unsigned<volatile  long> : public false_type{};
-template <> struct is_unsigned<const volatile  long> : public false_type{};
-#ifdef BOOST_HAS_LONG_LONG
-template <> struct is_unsigned< ::boost::ulong_long_type> : public true_type{};
-template <> struct is_unsigned<const ::boost::ulong_long_type> : public true_type{};
-template <> struct is_unsigned<volatile ::boost::ulong_long_type> : public true_type{};
-template <> struct is_unsigned<const volatile ::boost::ulong_long_type> : public true_type{};
-
-template <> struct is_unsigned< ::boost::long_long_type> : public false_type{};
-template <> struct is_unsigned<const ::boost::long_long_type> : public false_type{};
-template <> struct is_unsigned<volatile ::boost::long_long_type> : public false_type{};
-template <> struct is_unsigned<const volatile ::boost::long_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<unsigned char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const unsigned char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile unsigned char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile unsigned char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<unsigned short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const unsigned short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile unsigned short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile unsigned short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<unsigned int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const unsigned int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile unsigned int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile unsigned int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<unsigned long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const unsigned long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile unsigned long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile unsigned long> : public true_type{};
+
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<signed char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const signed char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile signed char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile signed char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned< short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const  short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile  short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile  short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned< int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const  int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile  int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile  int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned< long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const  long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile  long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile  long> : public false_type{};
+#ifndef BOOST_NO_LONG_LONG
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned< ::boost::ulong_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const ::boost::ulong_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile ::boost::ulong_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile ::boost::ulong_long_type> : public true_type{};
+
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned< ::boost::long_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const ::boost::long_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile ::boost::long_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile ::boost::long_long_type> : public false_type{};
 #endif
 #if defined(CHAR_MIN) 
 #if CHAR_MIN == 0
-template <> struct is_unsigned<char> : public true_type{};
-template <> struct is_unsigned<const char> : public true_type{};
-template <> struct is_unsigned<volatile char> : public true_type{};
-template <> struct is_unsigned<const volatile char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile char> : public true_type{};
 #else
-template <> struct is_unsigned<char> : public false_type{};
-template <> struct is_unsigned<const char> : public false_type{};
-template <> struct is_unsigned<volatile char> : public false_type{};
-template <> struct is_unsigned<const volatile char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile char> : public false_type{};
 #endif
 #endif
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && defined(WCHAR_MIN)
 #if WCHAR_MIN == 0
-template <> struct is_unsigned<wchar_t> : public true_type{};
-template <> struct is_unsigned<const wchar_t> : public true_type{};
-template <> struct is_unsigned<volatile wchar_t> : public true_type{};
-template <> struct is_unsigned<const volatile wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile wchar_t> : public true_type{};
 #else
-template <> struct is_unsigned<wchar_t> : public false_type{};
-template <> struct is_unsigned<const wchar_t> : public false_type{};
-template <> struct is_unsigned<volatile wchar_t> : public false_type{};
-template <> struct is_unsigned<const volatile wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<volatile wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_unsigned<const volatile wchar_t> : public false_type{};
 #endif
 #endif
 } // namespace boost
diff --git a/include/boost/type_traits/is_virtual_base_of.hpp b/include/boost/type_traits/is_virtual_base_of.hpp
index c665078bd3..ef8ece5dd7 100644
--- a/include/boost/type_traits/is_virtual_base_of.hpp
+++ b/include/boost/type_traits/is_virtual_base_of.hpp
@@ -12,7 +12,9 @@
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/make_void.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <utility>
+#endif
 
 namespace boost {
    namespace detail {
@@ -50,7 +52,7 @@ namespace boost {
 
    } // namespace detail
 
-   template<class T, class U>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
    struct is_virtual_base_of : public
       boost::integral_constant<
       bool,
@@ -129,13 +131,13 @@ namespace boost {
 
 } // namespace detail
 
-template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)> {};
 
 #endif
 
-template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived> : public false_type{};
-template <class Base, class Derived> struct is_virtual_base_of<Base, Derived&> : public false_type{};
-template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_virtual_base_of<Base, Derived&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived&> : public false_type{};
 
 #ifdef BOOST_MSVC
 #pragma warning( pop )
diff --git a/include/boost/type_traits/is_void.hpp b/include/boost/type_traits/is_void.hpp
index 183f8abf56..f32d81b053 100644
--- a/include/boost/type_traits/is_void.hpp
+++ b/include/boost/type_traits/is_void.hpp
@@ -13,13 +13,13 @@
 
 namespace boost {
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_void : public false_type {};
 
-template<> struct is_void<void> : public true_type {};
-template<> struct is_void<const void> : public true_type{};
-template<> struct is_void<const volatile void> : public true_type{};
-template<> struct is_void<volatile void> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_void<void> : public true_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_void<const void> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_void<const volatile void> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_void<volatile void> : public true_type{};
 
 } // namespace boost
 
diff --git a/include/boost/type_traits/is_volatile.hpp b/include/boost/type_traits/is_volatile.hpp
index 3f9b0630a7..7bccb221d8 100644
--- a/include/boost/type_traits/is_volatile.hpp
+++ b/include/boost/type_traits/is_volatile.hpp
@@ -21,23 +21,25 @@
 #ifndef BOOST_TT_IS_VOLATILE_HPP_INCLUDED
 #define BOOST_TT_IS_VOLATILE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_volatile : public integral_constant<bool, __is_volatile(T)> {};
 
 #else
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_volatile : public false_type {};
-   template <class T> struct is_volatile<T volatile> : public true_type{};
-   template <class T, std::size_t N> struct is_volatile<T volatile[N]> : public true_type{};
-   template <class T> struct is_volatile<T volatile[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_volatile<T volatile> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_volatile<T volatile[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_volatile<T volatile[]> : public true_type{};
 
 #endif
 
diff --git a/include/boost/type_traits/make_signed.hpp b/include/boost/type_traits/make_signed.hpp
index 6d8b1fb8d4..10f8534e9b 100644
--- a/include/boost/type_traits/make_signed.hpp
+++ b/include/boost/type_traits/make_signed.hpp
@@ -20,11 +20,13 @@
 #include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_volatile.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost {
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct make_signed
 {
 private:
@@ -127,7 +129,7 @@ struct make_signed
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using make_signed_t = typename make_signed<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using make_signed_t = typename make_signed<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/make_unsigned.hpp b/include/boost/type_traits/make_unsigned.hpp
index 17a8a5b929..b7d4812862 100644
--- a/include/boost/type_traits/make_unsigned.hpp
+++ b/include/boost/type_traits/make_unsigned.hpp
@@ -20,11 +20,13 @@
 #include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_volatile.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost {
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct make_unsigned
 {
 private:
@@ -126,7 +128,7 @@ struct make_unsigned
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using make_unsigned_t = typename make_unsigned<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using make_unsigned_t = typename make_unsigned<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/make_void.hpp b/include/boost/type_traits/make_void.hpp
index b8a72ef571..80380aa852 100644
--- a/include/boost/type_traits/make_void.hpp
+++ b/include/boost/type_traits/make_void.hpp
@@ -10,24 +10,24 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_TT_MAKE_VOID_HPP_INCLUDED
 #define BOOST_TT_MAKE_VOID_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class...>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class...>
 struct make_void {
     typedef void type;
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class... Ts>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class... Ts>
 using void_t = typename make_void<Ts...>::type;
 #endif
 
 #else /* BOOST_NO_CXX11_VARIADIC_TEMPLATES */
 
-template<class = void,
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class = void,
          class = void,
          class = void,
          class = void,
@@ -37,7 +37,7 @@ struct make_void {
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class A = void,
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class A = void,
          class B = void,
          class C = void,
          class D = void,
diff --git a/include/boost/type_traits/negation.hpp b/include/boost/type_traits/negation.hpp
index 939e7a7786..630a4038e8 100644
--- a/include/boost/type_traits/negation.hpp
+++ b/include/boost/type_traits/negation.hpp
@@ -14,7 +14,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct negation
     : integral_constant<bool, !bool(T::value)> { };
 
diff --git a/include/boost/type_traits/nonesuch.hpp b/include/boost/type_traits/nonesuch.hpp
index 7ba98c4bce..5b92fe5d35 100644
--- a/include/boost/type_traits/nonesuch.hpp
+++ b/include/boost/type_traits/nonesuch.hpp
@@ -10,19 +10,19 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_TT_NONESUCH_HPP_INCLUDED
 #define BOOST_TT_NONESUCH_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
 #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
-struct nonesuch {
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct nonesuch {
     nonesuch() = delete;
     ~nonesuch() = delete;
     nonesuch(const nonesuch&) = delete;
     void operator=(const nonesuch&) = delete;
 };
 #else
-class nonesuch {
+BOOST_TYPE_TRAITS_MODULE_EXPORT class nonesuch {
     nonesuch();
     ~nonesuch();
     nonesuch(const nonesuch&);
diff --git a/include/boost/type_traits/promote.hpp b/include/boost/type_traits/promote.hpp
index 1678e1ca3e..77bacf4e68 100644
--- a/include/boost/type_traits/promote.hpp
+++ b/include/boost/type_traits/promote.hpp
@@ -6,17 +6,17 @@
 #ifndef FILE_boost_type_traits_promote_hpp_INCLUDED
 #define FILE_boost_type_traits_promote_hpp_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/integral_promotion.hpp>
 #include <boost/type_traits/floating_point_promotion.hpp>
 
 namespace boost {
 
-template<class T> struct promote : public integral_promotion<typename floating_point_promotion<T>::type>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct promote : public integral_promotion<typename floating_point_promotion<T>::type>{};
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using promote_t = typename promote<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using promote_t = typename promote<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/rank.hpp b/include/boost/type_traits/rank.hpp
index db06cbd19e..3c16def689 100644
--- a/include/boost/type_traits/rank.hpp
+++ b/include/boost/type_traits/rank.hpp
@@ -10,7 +10,9 @@
 #ifndef BOOST_TT_RANK_HPP_INCLUDED
 #define BOOST_TT_RANK_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
@@ -77,9 +79,9 @@ struct rank_imp<T const volatile[], N>
 #endif // !defined( BOOST_CODEGEARC )
 
 #if defined( BOOST_CODEGEARC )
-template <class T> struct rank : public integral_constant<std::size_t, __array_rank(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct rank : public integral_constant<std::size_t, __array_rank(T)>{};
 #else
-template <class T> struct rank : public integral_constant<std::size_t, (::boost::detail::rank_imp<T, 0>::value)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct rank : public integral_constant<std::size_t, (::boost::detail::rank_imp<T, 0>::value)>{};
 #endif
 
 } // namespace boost
diff --git a/include/boost/type_traits/remove_all_extents.hpp b/include/boost/type_traits/remove_all_extents.hpp
index 4da725a33a..6102c2e896 100644
--- a/include/boost/type_traits/remove_all_extents.hpp
+++ b/include/boost/type_traits/remove_all_extents.hpp
@@ -9,30 +9,32 @@
 #ifndef BOOST_TT_REMOVE_ALL_EXTENTS_HPP_INCLUDED
 #define BOOST_TT_REMOVE_ALL_EXTENTS_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/detail/workaround.hpp>
+#endif
+
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-template <class T> struct remove_all_extents{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_all_extents{ typedef T type; };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template <class T, std::size_t N> struct remove_all_extents<T[N]> : public remove_all_extents<T>{};
-template <class T, std::size_t N> struct remove_all_extents<T const[N]> : public remove_all_extents<T const>{};
-template <class T, std::size_t N> struct remove_all_extents<T volatile[N]> : public remove_all_extents<T volatile>{};
-template <class T, std::size_t N> struct remove_all_extents<T const volatile[N]> : public remove_all_extents<T const volatile>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_all_extents<T[N]> : public remove_all_extents<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_all_extents<T const[N]> : public remove_all_extents<T const>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_all_extents<T volatile[N]> : public remove_all_extents<T volatile>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_all_extents<T const volatile[N]> : public remove_all_extents<T const volatile>{};
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
-template <class T> struct remove_all_extents<T[]> : public remove_all_extents<T>{};
-template <class T> struct remove_all_extents<T const[]> : public remove_all_extents<T const>{};
-template <class T> struct remove_all_extents<T volatile[]> : public remove_all_extents<T volatile>{};
-template <class T> struct remove_all_extents<T const volatile[]> : public remove_all_extents<T const volatile>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_all_extents<T[]> : public remove_all_extents<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_all_extents<T const[]> : public remove_all_extents<T const>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_all_extents<T volatile[]> : public remove_all_extents<T volatile>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_all_extents<T const volatile[]> : public remove_all_extents<T const volatile>{};
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_all_extents_t = typename remove_all_extents<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_all_extents_t = typename remove_all_extents<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_bounds.hpp b/include/boost/type_traits/remove_bounds.hpp
index cd0565d28f..7692318f09 100644
--- a/include/boost/type_traits/remove_bounds.hpp
+++ b/include/boost/type_traits/remove_bounds.hpp
@@ -14,11 +14,11 @@
 namespace boost 
 {
 
-template <class T> struct remove_bounds : public remove_extent<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_bounds : public remove_extent<T> {};
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-template <class T> using remove_bounds_t = typename remove_bounds<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_bounds_t = typename remove_bounds<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_const.hpp b/include/boost/type_traits/remove_const.hpp
index 045c6b8228..aa06c08b88 100644
--- a/include/boost/type_traits/remove_const.hpp
+++ b/include/boost/type_traits/remove_const.hpp
@@ -11,26 +11,27 @@
 #ifndef BOOST_TT_REMOVE_CONST_HPP_INCLUDED
 #define BOOST_TT_REMOVE_CONST_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/detail/workaround.hpp>
+#endif
 
 namespace boost {
 
    //  convert a type T to a non-cv-qualified type - remove_const<T>
-   template <class T> struct remove_const{ typedef T type; };
-   template <class T> struct remove_const<T const>{ typedef T type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_const{ typedef T type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_const<T const>{ typedef T type; };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-   template <class T, std::size_t N> struct remove_const<T const[N]>{ typedef T type[N]; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_const<T const[N]>{ typedef T type[N]; };
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
-   template <class T> struct remove_const<T const[]>{ typedef T type[]; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_const<T const[]>{ typedef T type[]; };
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_const_t = typename remove_const<T>::type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_const_t = typename remove_const<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_cv.hpp b/include/boost/type_traits/remove_cv.hpp
index 2a68af533e..9e6ffb6318 100644
--- a/include/boost/type_traits/remove_cv.hpp
+++ b/include/boost/type_traits/remove_cv.hpp
@@ -11,32 +11,33 @@
 #ifndef BOOST_TT_REMOVE_CV_HPP_INCLUDED
 #define BOOST_TT_REMOVE_CV_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 
 namespace boost {
 
    //  convert a type T to a non-cv-qualified type - remove_cv<T>
-template <class T> struct remove_cv{ typedef T type; };
-template <class T> struct remove_cv<T const>{ typedef T type;  };
-template <class T> struct remove_cv<T volatile>{ typedef T type; };
-template <class T> struct remove_cv<T const volatile>{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv<T const>{ typedef T type;  };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv<T volatile>{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv<T const volatile>{ typedef T type; };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template <class T, std::size_t N> struct remove_cv<T const[N]>{ typedef T type[N]; };
-template <class T, std::size_t N> struct remove_cv<T const volatile[N]>{ typedef T type[N]; };
-template <class T, std::size_t N> struct remove_cv<T volatile[N]>{ typedef T type[N]; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_cv<T const[N]>{ typedef T type[N]; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_cv<T const volatile[N]>{ typedef T type[N]; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_cv<T volatile[N]>{ typedef T type[N]; };
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
-template <class T> struct remove_cv<T const[]>{ typedef T type[]; };
-template <class T> struct remove_cv<T const volatile[]>{ typedef T type[]; };
-template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv<T const[]>{ typedef T type[]; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv<T const volatile[]>{ typedef T type[]; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_cv_t = typename remove_cv<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_cv_t = typename remove_cv<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_cv_ref.hpp b/include/boost/type_traits/remove_cv_ref.hpp
index 118945a6a0..78ea3136e3 100644
--- a/include/boost/type_traits/remove_cv_ref.hpp
+++ b/include/boost/type_traits/remove_cv_ref.hpp
@@ -10,18 +10,18 @@
 #ifndef BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
 #define BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 
 namespace boost {
 
-   template <class T> struct remove_cv_ref: remove_cv<typename remove_reference<T>::type> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_cv_ref: remove_cv<typename remove_reference<T>::type> {};
 
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_cv_ref_t = typename remove_cv_ref<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_cv_ref_t = typename remove_cv_ref<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_extent.hpp b/include/boost/type_traits/remove_extent.hpp
index 866f4bce07..62a4eee3a9 100644
--- a/include/boost/type_traits/remove_extent.hpp
+++ b/include/boost/type_traits/remove_extent.hpp
@@ -9,30 +9,31 @@
 #ifndef BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED
 #define BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 
 namespace boost {
 
-template <class T> struct remove_extent{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_extent{ typedef T type; };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template <typename T, std::size_t N> struct remove_extent<T[N]> { typedef T type; };
-template <typename T, std::size_t N> struct remove_extent<T const[N]> { typedef T const type; };
-template <typename T, std::size_t N> struct remove_extent<T volatile [N]> { typedef T volatile type; };
-template <typename T, std::size_t N> struct remove_extent<T const volatile [N]> { typedef T const volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct remove_extent<T[N]> { typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct remove_extent<T const[N]> { typedef T const type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct remove_extent<T volatile [N]> { typedef T volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct remove_extent<T const volatile [N]> { typedef T const volatile type; };
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
-template <typename T> struct remove_extent<T[]> { typedef T type; };
-template <typename T> struct remove_extent<T const[]> { typedef T const type; };
-template <typename T> struct remove_extent<T volatile[]> { typedef T volatile type; };
-template <typename T> struct remove_extent<T const volatile[]> { typedef T const volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct remove_extent<T[]> { typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct remove_extent<T const[]> { typedef T const type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct remove_extent<T volatile[]> { typedef T volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct remove_extent<T const volatile[]> { typedef T const volatile type; };
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_extent_t = typename remove_extent<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_extent_t = typename remove_extent<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_pointer.hpp b/include/boost/type_traits/remove_pointer.hpp
index ce32f186ae..ac7d378d2f 100644
--- a/include/boost/type_traits/remove_pointer.hpp
+++ b/include/boost/type_traits/remove_pointer.hpp
@@ -9,8 +9,7 @@
 #ifndef BOOST_TT_REMOVE_POINTER_HPP_INCLUDED
 #define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if defined(BOOST_MSVC)
 #include <boost/type_traits/remove_cv.hpp>
@@ -65,17 +64,17 @@ template <class T> struct remove_pointer{ typedef typename boost::detail::remove
 
 #else
 
-template <class T> struct remove_pointer{ typedef T type; };
-template <class T> struct remove_pointer<T*>{ typedef T type; };
-template <class T> struct remove_pointer<T*const>{ typedef T type; };
-template <class T> struct remove_pointer<T*volatile>{ typedef T type; };
-template <class T> struct remove_pointer<T*const volatile>{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_pointer{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_pointer<T*>{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_pointer<T*const>{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_pointer<T*volatile>{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_pointer<T*const volatile>{ typedef T type; };
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_pointer_t = typename remove_pointer<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_pointer_t = typename remove_pointer<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_reference.hpp b/include/boost/type_traits/remove_reference.hpp
index 70949fbb2a..807a3ff766 100644
--- a/include/boost/type_traits/remove_reference.hpp
+++ b/include/boost/type_traits/remove_reference.hpp
@@ -9,8 +9,7 @@
 #ifndef BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED
 #define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
@@ -35,8 +34,8 @@ struct remove_rvalue_ref<T&&>
 
 } // namespace detail
 
-template <class T> struct remove_reference{ typedef typename boost::detail::remove_rvalue_ref<T>::type type; };
-template <class T> struct remove_reference<T&>{ typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_reference{ typedef typename boost::detail::remove_rvalue_ref<T>::type type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_reference<T&>{ typedef T type; };
 
 #if defined(BOOST_ILLEGAL_CV_REFERENCES)
 // these are illegal specialisations; cv-qualifies applied to
@@ -50,7 +49,7 @@ template <class T> struct remove_reference<T&const volatile>{ typedef T type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_reference_t = typename remove_reference<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_reference_t = typename remove_reference<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/remove_volatile.hpp b/include/boost/type_traits/remove_volatile.hpp
index 162d0c2a7f..4dd1f354ea 100644
--- a/include/boost/type_traits/remove_volatile.hpp
+++ b/include/boost/type_traits/remove_volatile.hpp
@@ -11,26 +11,27 @@
 #ifndef BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED
 #define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 
 namespace boost {
 
    //  convert a type T to a non-cv-qualified type - remove_volatile<T>
-   template <class T> struct remove_volatile{ typedef T type; };
-   template <class T> struct remove_volatile<T volatile>{ typedef T type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_volatile{ typedef T type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_volatile<T volatile>{ typedef T type; };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-   template <class T, std::size_t N> struct remove_volatile<T volatile[N]>{ typedef T type[N]; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct remove_volatile<T volatile[N]>{ typedef T type[N]; };
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
-   template <class T> struct remove_volatile<T volatile[]>{ typedef T type[]; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct remove_volatile<T volatile[]>{ typedef T type[]; };
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using remove_volatile_t = typename remove_volatile<T>::type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using remove_volatile_t = typename remove_volatile<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/type_identity.hpp b/include/boost/type_traits/type_identity.hpp
index 4a03a13a39..ea0e301cb7 100644
--- a/include/boost/type_traits/type_identity.hpp
+++ b/include/boost/type_traits/type_identity.hpp
@@ -9,19 +9,19 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost
 {
 
-template<class T> struct type_identity
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct type_identity
 {
     typedef T type;
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-template <class T> using type_identity_t = typename type_identity<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using type_identity_t = typename type_identity<T>::type;
 
 #endif
 
diff --git a/include/boost/type_traits/type_with_alignment.hpp b/include/boost/type_traits/type_with_alignment.hpp
index e4860f9fd3..7e88494f73 100644
--- a/include/boost/type_traits/type_with_alignment.hpp
+++ b/include/boost/type_traits/type_with_alignment.hpp
@@ -8,12 +8,15 @@
 #ifndef BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED
 #define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED
 
-#include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/is_pod.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
-#include <boost/config.hpp>
 #include <cstddef> // size_t
-#include <boost/detail/workaround.hpp>
+#endif
+
+#include <boost/type_traits/detail/config.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/is_pod.hpp>
+
 
 #ifdef BOOST_MSVC
 #   pragma warning(push)
@@ -77,7 +80,7 @@ template <std::size_t Target> struct char_alignment<Target, false>{ typedef type
 
 } // namespace detail
 
-template <std::size_t Align>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <std::size_t Align>
 struct type_with_alignment 
 {
    typedef typename boost::detail::char_alignment<Align, boost::alignment_of<char>::value >= Align>::type type;
@@ -85,31 +88,31 @@ struct type_with_alignment
 
 #if (defined(__GNUC__) || (defined (__SUNPRO_CC) &&  (__SUNPRO_CC >= 0x5130)) || defined(__clang__)) && !defined(BOOST_TT_DISABLE_INTRINSICS)
 namespace tt_align_ns {
-struct __attribute__((__aligned__(2))) a2 {};
-struct __attribute__((__aligned__(4))) a4 {};
-struct __attribute__((__aligned__(8))) a8 {};
-struct __attribute__((__aligned__(16))) a16 {};
-struct __attribute__((__aligned__(32))) a32 {};
-struct __attribute__((__aligned__(64))) a64 {};
-struct __attribute__((__aligned__(128))) a128 {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __attribute__((__aligned__(2))) a2 {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __attribute__((__aligned__(4))) a4 {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __attribute__((__aligned__(8))) a8 {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __attribute__((__aligned__(16))) a16 {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __attribute__((__aligned__(32))) a32 {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __attribute__((__aligned__(64))) a64 {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __attribute__((__aligned__(128))) a128 {};
 }
 
-template<> struct type_with_alignment<1>  { public: typedef char type; };
-template<> struct type_with_alignment<2>  { public: typedef tt_align_ns::a2 type; };
-template<> struct type_with_alignment<4>  { public: typedef tt_align_ns::a4 type; };
-template<> struct type_with_alignment<8>  { public: typedef tt_align_ns::a8 type; };
-template<> struct type_with_alignment<16> { public: typedef tt_align_ns::a16 type; };
-template<> struct type_with_alignment<32> { public: typedef tt_align_ns::a32 type; };
-template<> struct type_with_alignment<64> { public: typedef tt_align_ns::a64 type; };
-template<> struct type_with_alignment<128> { public: typedef tt_align_ns::a128 type; };
-
-template<> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<1>  { public: typedef char type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<2>  { public: typedef tt_align_ns::a2 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<4>  { public: typedef tt_align_ns::a4 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<8>  { public: typedef tt_align_ns::a8 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<16> { public: typedef tt_align_ns::a16 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<32> { public: typedef tt_align_ns::a32 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<64> { public: typedef tt_align_ns::a64 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<128> { public: typedef tt_align_ns::a128 type; };
+
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
 
 #endif
 #if (defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && !defined(BOOST_TT_DISABLE_INTRINSICS)
@@ -130,30 +133,30 @@ template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
 // in the matter because no other "ordinary" type is available.
 //
 namespace tt_align_ns {
-struct __declspec(align(8)) a8 { 
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __declspec(align(8)) a8 { 
    char m[8]; 
    typedef a8 type;
 };
-struct __declspec(align(16)) a16 { 
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __declspec(align(16)) a16 {
    char m[16]; 
    typedef a16 type;
 };
-struct __declspec(align(32)) a32 { 
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __declspec(align(32)) a32 {
    char m[32]; 
    typedef a32 type;
 };
-struct __declspec(align(64)) a64 
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __declspec(align(64)) a64
 { 
    char m[64]; 
    typedef a64 type;
 };
-struct __declspec(align(128)) a128 { 
+BOOST_TYPE_TRAITS_MODULE_EXPORT struct __declspec(align(128)) a128 {
    char m[128]; 
    typedef a128 type;
 };
 }
 
-template<> struct type_with_alignment<8>  
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<8>
 { 
    typedef boost::conditional<
       ::boost::alignment_of<boost::detail::max_align>::value < 8,
@@ -162,7 +165,7 @@ template<> struct type_with_alignment<8>
 public: 
    typedef t1::type type;
 };
-template<> struct type_with_alignment<16> 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<16>
 { 
    typedef boost::conditional<
       ::boost::alignment_of<boost::detail::max_align>::value < 16,
@@ -171,7 +174,7 @@ template<> struct type_with_alignment<16>
 public: 
    typedef t1::type type;
 };
-template<> struct type_with_alignment<32> 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<32>
 { 
    typedef boost::conditional<
       ::boost::alignment_of<boost::detail::max_align>::value < 32,
@@ -180,7 +183,7 @@ template<> struct type_with_alignment<32>
 public: 
    typedef t1::type type;
 };
-template<> struct type_with_alignment<64> {
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<64> {
    typedef boost::conditional<
       ::boost::alignment_of<boost::detail::max_align>::value < 64,
       tt_align_ns::a64,
@@ -188,7 +191,7 @@ template<> struct type_with_alignment<64> {
 public: 
    typedef t1::type type;
 };
-template<> struct type_with_alignment<128> {
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct type_with_alignment<128> {
    typedef boost::conditional<
       ::boost::alignment_of<boost::detail::max_align>::value < 128,
       tt_align_ns::a128,
@@ -197,11 +200,11 @@ template<> struct type_with_alignment<128> {
    typedef t1::type type;
 };
 
-template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
-template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
 
 #endif
 
@@ -234,18 +237,18 @@ template <> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
 template <> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
 //#endif
 
-template <std::size_t N> struct type_with_alignment
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <std::size_t N> struct type_with_alignment
 {
    // We should never get to here, but if we do use the maximally
    // aligned type:
    // BOOST_STATIC_ASSERT(0);
    typedef tt_align_ns::a16 type;
 };
-template <> struct type_with_alignment<1>{ typedef char type; };
-template <> struct type_with_alignment<2>{ typedef tt_align_ns::a2 type; };
-template <> struct type_with_alignment<4>{ typedef tt_align_ns::a4 type; };
-template <> struct type_with_alignment<8>{ typedef tt_align_ns::a8 type; };
-template <> struct type_with_alignment<16>{ typedef tt_align_ns::a16 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct type_with_alignment<1>{ typedef char type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct type_with_alignment<2>{ typedef tt_align_ns::a2 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct type_with_alignment<4>{ typedef tt_align_ns::a4 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct type_with_alignment<8>{ typedef tt_align_ns::a8 type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct type_with_alignment<16>{ typedef tt_align_ns::a16 type; };
 
 #endif
 
diff --git a/module/type_traits.cxx b/module/type_traits.cxx
new file mode 100644
index 0000000000..08954379f1
--- /dev/null
+++ b/module/type_traits.cxx
@@ -0,0 +1,180 @@
+//  (C) John Maddock 2022.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+module;
+
+#ifdef _MSC_VER
+#pragma warning( disable : 5244)
+#endif
+
+#include <cstddef>
+#include <utility>
+#include <new>
+#include <utility>
+#include <complex>
+#include <algorithm>
+#include <climits>
+#include <boost/config.hpp>
+#include <boost/version.hpp>
+#include <boost/config/workaround.hpp>
+
+export module boost.type_traits;
+
+#define BOOST_TYPE_TRAITS_AS_MODULE
+#define BOOST_TYPE_TRAITS_MODULE_EXPORT export
+
+#include <boost/type_traits.hpp>
+#if 0
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_cv.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/add_rvalue_reference.hpp>
+#include <boost/type_traits/add_volatile.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/conjunction.hpp>
+#include <boost/type_traits/copy_cv.hpp>
+#include <boost/type_traits/copy_cv_ref.hpp>
+#include <boost/type_traits/copy_reference.hpp>
+#include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/detected.hpp>
+#include <boost/type_traits/detected_or.hpp>
+#include <boost/type_traits/disjunction.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/extent.hpp>
+#include <boost/type_traits/floating_point_promotion.hpp>
+#include <boost/type_traits/function_traits.hpp>
+#include <boost/type_traits/has_bit_and.hpp>
+#include <boost/type_traits/has_bit_and_assign.hpp>
+#include <boost/type_traits/has_bit_or.hpp>
+#include <boost/type_traits/has_bit_or_assign.hpp>
+#include <boost/type_traits/has_bit_xor.hpp>
+#include <boost/type_traits/has_bit_xor_assign.hpp>
+#include <boost/type_traits/has_complement.hpp>
+#include <boost/type_traits/has_dereference.hpp>
+#include <boost/type_traits/has_divides.hpp>
+#include <boost/type_traits/has_divides_assign.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
+#include <boost/type_traits/has_greater.hpp>
+#include <boost/type_traits/has_greater_equal.hpp>
+#include <boost/type_traits/has_left_shift.hpp>
+#include <boost/type_traits/has_left_shift_assign.hpp>
+#include <boost/type_traits/has_less.hpp>
+#include <boost/type_traits/has_less_equal.hpp>
+#include <boost/type_traits/has_logical_and.hpp>
+#include <boost/type_traits/has_logical_or.hpp>
+#include <boost/type_traits/has_logical_not.hpp>
+#include <boost/type_traits/has_minus.hpp>
+#include <boost/type_traits/has_minus_assign.hpp>
+#include <boost/type_traits/has_modulus.hpp>
+#include <boost/type_traits/has_modulus_assign.hpp>
+#include <boost/type_traits/has_multiplies.hpp>
+#include <boost/type_traits/has_multiplies_assign.hpp>
+#include <boost/type_traits/has_negate.hpp>
+#include <boost/type_traits/has_new_operator.hpp>
+#include <boost/type_traits/has_not_equal_to.hpp>
+#include <boost/type_traits/has_nothrow_assign.hpp>
+#include <boost/type_traits/has_nothrow_constructor.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/type_traits/has_nothrow_destructor.hpp>
+#include <boost/type_traits/has_plus.hpp>
+#include <boost/type_traits/has_plus_assign.hpp>
+#include <boost/type_traits/has_post_increment.hpp>
+#include <boost/type_traits/has_post_decrement.hpp>
+#include <boost/type_traits/has_pre_increment.hpp>
+#include <boost/type_traits/has_pre_decrement.hpp>
+#include <boost/type_traits/has_right_shift.hpp>
+#include <boost/type_traits/has_right_shift_assign.hpp>
+#include <boost/type_traits/has_trivial_assign.hpp>
+#include <boost/type_traits/has_trivial_constructor.hpp>
+#include <boost/type_traits/has_trivial_copy.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/type_traits/has_trivial_move_assign.hpp>
+#include <boost/type_traits/has_trivial_move_constructor.hpp>
+#include <boost/type_traits/has_unary_plus.hpp>
+#include <boost/type_traits/has_unary_minus.hpp>
+#include <boost/type_traits/has_virtual_destructor.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_assignable.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_bounded_array.hpp>
+#include <boost/type_traits/is_complete.hpp>
+#include <boost/type_traits/is_complex.hpp>
+#include <boost/type_traits/is_compound.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/is_copy_assignable.hpp>
+#include <boost/type_traits/is_copy_constructible.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_default_constructible.hpp>
+#include <boost/type_traits/is_destructible.hpp>
+#include <boost/type_traits/is_detected.hpp>
+#include <boost/type_traits/is_detected_convertible.hpp>
+#include <boost/type_traits/is_detected_exact.hpp>
+#include <boost/type_traits/is_empty.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_final.hpp>
+#include <boost/type_traits/is_float.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_list_constructible.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/type_traits/is_member_object_pointer.hpp>
+#include <boost/type_traits/is_member_pointer.hpp>
+#include <boost/type_traits/is_noncopyable.hpp>
+#include <boost/type_traits/is_nothrow_move_assignable.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/type_traits/is_nothrow_swappable.hpp>
+#include <boost/type_traits/is_object.hpp>
+#include <boost/type_traits/is_pod.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_rvalue_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_scoped_enum.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_stateless.hpp>
+#include <boost/type_traits/is_trivially_copyable.hpp>
+#include <boost/type_traits/is_unbounded_array.hpp>
+#include <boost/type_traits/is_union.hpp>
+#include <boost/type_traits/is_unscoped_enum.hpp>
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/is_virtual_base_of.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/negation.hpp>
+#include <boost/type_traits/nonesuch.hpp>
+#include <boost/type_traits/promote.hpp>
+#include <boost/type_traits/rank.hpp>
+#include <boost/type_traits/remove_all_extents.hpp>
+#include <boost/type_traits/remove_bounds.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_cv_ref.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_volatile.hpp>
+#include <boost/type_traits/type_identity.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/type_traits/is_same.hpp>
+#endif
diff --git a/test/test_module.cpp b/test/test_module.cpp
new file mode 100644
index 0000000000..82bb282246
--- /dev/null
+++ b/test/test_module.cpp
@@ -0,0 +1,243 @@
+//  (C) John Maddock 2022.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#include <complex>
+
+import boost.type_traits;
+
+template<class T>
+using type_t = typename T::type;
+
+struct has_type {
+   using type = char;
+};
+
+
+int main()
+{
+   {
+      using t1 = boost::add_const_t<int>;
+      static_assert(boost::is_same<t1, const int>::value);
+   }
+   {
+      using t1 = boost::add_cv_t<int>;
+      static_assert(boost::is_same<t1, const volatile int>::value);
+   }
+   {
+      using t1 = boost::add_reference_t<int>;
+      static_assert(boost::is_same<t1, int&>::value);
+   }
+   {
+      using t1 = boost::add_lvalue_reference_t<int>;
+      static_assert(boost::is_same<t1, int&>::value);
+   }
+   {
+      using t1 = boost::add_pointer_t<int>;
+      static_assert(boost::is_same<t1, int*>::value);
+   }
+   {
+      using t1 = boost::add_rvalue_reference_t<int>;
+      static_assert(boost::is_same<t1, int&&>::value);
+   }
+   {
+      using t1 = boost::add_volatile_t<int>;
+      static_assert(boost::is_same<t1, volatile int>::value);
+   }
+   {
+      using t1 = boost::common_type<int, long>::type;
+      static_assert(boost::is_same<t1, long>::value);
+   }
+   {
+      using t1 = boost::conditional<true, long, int>::type;
+      static_assert(boost::is_same<t1, long>::value);
+   }
+   {
+      using t1 = boost::conjunction<boost::true_type, boost::false_type>::type;
+      static_assert(boost::is_same<t1, boost::false_type>::value);
+   }
+   {
+      using t1 = boost::copy_cv<int, const long>::type;
+      static_assert(boost::is_same<t1, const int>::value);
+   }
+   {
+      using t1 = boost::copy_cv<int&, const char&>::type;
+      static_assert(boost::is_same<t1, int&>::value);
+   }
+   {
+      using t1 = boost::copy_cv<int, const char&>::type;
+      static_assert(boost::is_same<t1, int>::value);
+   }
+   {
+      using t1 = boost::decay<int[2]>::type;
+      static_assert(boost::is_same<t1, int*>::value);
+   }
+   {
+      static_assert(boost::is_same<boost::detected_t<type_t, has_type>, char>::value);
+   }
+   {
+      static_assert(boost::detected_or<bool, type_t, has_type>::value_t::value);
+   }
+   {
+      using t1 = boost::disjunction<boost::true_type, boost::false_type>::type;
+      static_assert(boost::is_same<t1, boost::true_type>::value);
+   }
+   {
+      static_assert(boost::extent<int[3]>::value == 3);
+   }
+   {
+      using t1 = boost::floating_point_promotion<const float>::type;
+      static_assert(boost::is_same<t1, const double>::value);
+   }
+   {
+      typedef int(t1)(int, int);
+      static_assert(boost::function_traits<t1>::arity == 2);
+   }
+   {
+      static_assert(boost::has_bit_and<int>::value);
+      static_assert(boost::has_bit_and_assign<int>::value);
+      static_assert(boost::has_bit_or<int>::value);
+      static_assert(boost::has_bit_or_assign<int>::value);
+      static_assert(boost::has_bit_xor<int>::value);
+      static_assert(boost::has_bit_xor_assign<int>::value);
+      static_assert(boost::has_complement<int>::value);
+      static_assert(boost::has_dereference<int*>::value);
+      static_assert(!boost::has_dereference<int>::value);
+      static_assert(boost::has_divides<int>::value);
+      static_assert(boost::has_divides_assign<int>::value);
+      static_assert(boost::has_equal_to<int>::value);
+      static_assert(boost::has_greater<int>::value);
+      static_assert(boost::has_greater_equal<int>::value);
+      static_assert(boost::has_left_shift<int>::value);
+      static_assert(boost::has_left_shift_assign<int>::value);
+      static_assert(boost::has_less<int>::value);
+      static_assert(boost::has_less_equal<int>::value);
+      static_assert(boost::has_logical_and<int>::value);
+      static_assert(boost::has_logical_or<int>::value);
+      static_assert(boost::has_logical_not<int>::value);
+      static_assert(boost::has_minus<int>::value);
+      static_assert(boost::has_minus_assign<int>::value);
+      static_assert(boost::has_modulus<int>::value);
+      static_assert(boost::has_modulus_assign<int>::value);
+      static_assert(boost::has_multiplies<int>::value);
+      static_assert(boost::has_multiplies_assign<int>::value);
+      static_assert(boost::has_negate<int>::value);
+      static_assert(!boost::has_new_operator<int>::value);
+      static_assert(boost::has_not_equal_to<int>::value);
+      static_assert(boost::has_nothrow_assign<int>::value);
+      static_assert(boost::has_nothrow_constructor<int>::value);
+      static_assert(boost::has_nothrow_copy_constructor<int>::value);
+      static_assert(boost::has_nothrow_destructor<int>::value);
+      static_assert(boost::has_plus<int>::value);
+      static_assert(boost::has_plus_assign<int>::value);
+      static_assert(boost::has_post_increment<int>::value);
+      static_assert(boost::has_post_decrement<int>::value);
+      static_assert(boost::has_pre_increment<int>::value);
+      static_assert(boost::has_pre_decrement<int>::value);
+      static_assert(boost::has_right_shift<int>::value);
+      static_assert(boost::has_right_shift_assign<int>::value);
+      static_assert(boost::has_trivial_assign<int>::value);
+      static_assert(boost::has_trivial_constructor<int>::value);
+      static_assert(boost::has_trivial_copy<int>::value);
+      static_assert(boost::has_trivial_destructor<int>::value);
+      static_assert(boost::has_trivial_move_assign<int>::value);
+      static_assert(boost::has_trivial_move_constructor<int>::value);
+      static_assert(boost::has_unary_plus<int>::value);
+      static_assert(boost::has_unary_minus<int>::value);
+      static_assert(!boost::has_virtual_destructor<int>::value);
+      
+      static_assert(!boost::is_abstract<int>::value);
+      static_assert(boost::is_arithmetic<int>::value);
+      static_assert(!boost::is_array<int>::value);
+      static_assert(boost::is_assignable<int&>::value);
+      static_assert(!boost::is_base_of<int, double>::value);
+      static_assert(!boost::is_base_and_derived<int, double>::value);
+      static_assert(!boost::is_bounded_array<int[]>::value);
+      static_assert(boost::is_bounded_array<int[2]>::value);
+      static_assert(boost::is_complete<int>::value);
+      static_assert(boost::is_complex<std::complex<double>>::value);
+      static_assert(!boost::is_compound<int>::value);
+      static_assert(!boost::is_const<int>::value);
+      static_assert(boost::is_const<const int>::value);
+      static_assert(boost::is_convertible<int, double>::value);
+      static_assert(boost::is_constructible<int, double>::value);
+      static_assert(boost::is_copy_assignable<int>::value);
+      static_assert(boost::is_copy_constructible<int>::value);
+      static_assert(!boost::is_class<int>::value);
+      static_assert(boost::is_class<std::complex<double>>::value);
+      static_assert(boost::is_default_constructible<int>::value);
+      static_assert(boost::is_destructible<int>::value);
+      static_assert(!boost::is_detected<type_t, int>::value);
+      static_assert(boost::is_detected<type_t, has_type>::value);
+      static_assert(boost::is_detected_convertible<int, type_t, has_type>::value);
+      static_assert(boost::is_detected_exact<char, type_t, has_type>::value);
+      static_assert(!boost::is_empty<std::complex<double>>::value);
+      static_assert(!boost::is_enum<int>::value);
+      static_assert(!boost::is_final<std::complex<double>>::value);
+      static_assert(boost::is_float<double>::value);
+      static_assert(boost::is_floating_point<double>::value);
+      static_assert(boost::is_function<double(int)>::value);
+      static_assert(boost::is_fundamental<int>::value);
+      static_assert(boost::is_integral<int>::value);
+      static_assert(boost::is_list_constructible<int[2]>::value);
+      static_assert(boost::is_lvalue_reference<int&>::value);
+      static_assert(boost::is_member_function_pointer<double (std::complex<double>::*)()>::value);
+      static_assert(!boost::is_member_object_pointer<double (std::complex<double>::*)()>::value);
+      static_assert(boost::is_member_pointer<double (std::complex<double>::*)()>::value);
+      static_assert(!boost::is_noncopyable<std::complex<double>>::value);
+      static_assert(boost::is_nothrow_move_assignable<int>::value);
+      static_assert(boost::is_nothrow_move_constructible<int>::value);
+      static_assert(boost::is_nothrow_swappable<int>::value);
+      static_assert(boost::is_object<int>::value);
+      static_assert(boost::is_pod<int>::value);
+      static_assert(!boost::is_polymorphic<int>::value);
+      static_assert(boost::is_reference<int&>::value);
+      static_assert(boost::is_rvalue_reference<int&&>::value);
+      static_assert(boost::is_same<int, int>::value);
+      static_assert(!boost::is_scoped_enum<int>::value);
+      static_assert(boost::is_scalar<int>::value);
+      static_assert(boost::is_signed<int>::value);
+      static_assert(!boost::is_stateless<int>::value);
+      static_assert(boost::is_trivially_copyable<int>::value);
+      static_assert(boost::is_unbounded_array<int[]>::value);
+      static_assert(!boost::is_union<int>::value);
+      static_assert(!boost::is_unscoped_enum<int>::value);
+      static_assert(boost::is_unsigned<unsigned int>::value);
+      static_assert(!boost::is_virtual_base_of<std::complex<float>, std::complex<double>>::value);
+      static_assert(boost::is_void<void const>::value);
+      static_assert(boost::is_volatile<volatile int>::value);
+      static_assert(boost::is_same<boost::make_signed_t<unsigned int>, int>::value);
+      static_assert(boost::is_same<boost::make_unsigned_t<int>, unsigned>::value);
+      static_assert(boost::negation<boost::is_void<int>>::value);
+      static_assert(boost::is_same<boost::promote_t<short>, int>::value);
+      static_assert(boost::rank<int[2][3]>::value == 2);
+      static_assert(boost::is_same<boost::remove_all_extents_t<int[2][3]>, int>::value);
+      static_assert(boost::is_same<boost::remove_bounds_t<int[2][3]>, int[3]>::value);
+      static_assert(boost::is_same<boost::remove_const_t<int const>, int>::value);
+      static_assert(boost::is_same<boost::remove_cv_t<int const>, int>::value);
+      static_assert(boost::is_same<boost::remove_cv_ref_t<int const&>, int>::value);
+      static_assert(boost::is_same<boost::remove_extent_t<int[2][3]>, int[3]>::value);
+      static_assert(boost::is_same<boost::remove_pointer_t<int**>, int*>::value);
+      static_assert(boost::is_same<boost::remove_reference_t<int&>, int>::value);
+      static_assert(boost::is_same<boost::remove_volatile_t<int const volatile>, int const>::value);
+      static_assert(boost::is_same<boost::type_identity_t<int>, int>::value);
+      static_assert(boost::alignment_of<boost::type_with_alignment<16>::type>::value == 16);
+   }
+   
+   {
+      using t1 = boost::remove_reference_t<int&>;
+      static_assert(boost::is_same<t1, int>::value);
+   }
+   {
+      using t1 = boost::aligned_storage<8>::type;
+      using t2 = boost::aligned_storage<64>::type;
+   }
+   {
+      using t1 = boost::type_with_alignment<8>::type;
+      using t2 = boost::type_with_alignment<64>::type;
+   }
+}
+