diff --git a/include/seqan3/alignment/configuration/align_config_scoring_scheme.hpp b/include/seqan3/alignment/configuration/align_config_scoring_scheme.hpp
index 797e6094ff..d29cf6f487 100644
--- a/include/seqan3/alignment/configuration/align_config_scoring_scheme.hpp
+++ b/include/seqan3/alignment/configuration/align_config_scoring_scheme.hpp
@@ -16,9 +16,9 @@
 #include <seqan3/std/concepts>
 
 #include <seqan3/alignment/configuration/detail.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/alignment/scoring/scoring_scheme_concept.hpp>
 #include <seqan3/core/algorithm/pipeable_config_element.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::align_cfg
 {
diff --git a/include/seqan3/alignment/matrix/alignment_coordinate.hpp b/include/seqan3/alignment/matrix/alignment_coordinate.hpp
index 561d79f0e7..ef590944a6 100644
--- a/include/seqan3/alignment/matrix/alignment_coordinate.hpp
+++ b/include/seqan3/alignment/matrix/alignment_coordinate.hpp
@@ -12,15 +12,15 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+#include <seqan3/std/iterator>
 #include <type_traits>
 
 #include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
 #include <seqan3/core/detail/debug_stream_tuple.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
 #include <seqan3/core/detail/strong_type.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/iterator>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/matrix/alignment_optimum.hpp b/include/seqan3/alignment/matrix/alignment_optimum.hpp
index 1195350ac6..6b02ae6609 100644
--- a/include/seqan3/alignment/matrix/alignment_optimum.hpp
+++ b/include/seqan3/alignment/matrix/alignment_optimum.hpp
@@ -16,7 +16,7 @@
 
 #include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
 #include <seqan3/core/concept/core_language.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/core/simd/concept.hpp>
 #include <seqan3/core/simd/simd_algorithm.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
diff --git a/include/seqan3/alignment/matrix/debug_matrix.hpp b/include/seqan3/alignment/matrix/debug_matrix.hpp
index 48ec61e50f..44134d6137 100644
--- a/include/seqan3/alignment/matrix/debug_matrix.hpp
+++ b/include/seqan3/alignment/matrix/debug_matrix.hpp
@@ -21,7 +21,7 @@
 #include <seqan3/core/detail/debug_stream_range.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
 #include <seqan3/core/detail/debug_stream_optional.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp b/include/seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp
index ca8179cc2e..bee88112b5 100644
--- a/include/seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp
+++ b/include/seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp
@@ -12,6 +12,8 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+#include <seqan3/std/ranges>
 #include <type_traits>
 #include <vector>
 
@@ -19,15 +21,14 @@
 #include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
 #include <seqan3/alignment/matrix/trace_directions.hpp>
 #include <seqan3/alphabet/gap/gapped.hpp>
-#include <seqan3/core/type_traits/concept.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
+#include <seqan3/core/detail/is_class_template_declarable.hpp>
 #include <seqan3/range/decorator/gap_decorator.hpp>
 #include <seqan3/range/views/convert.hpp>
 #include <seqan3/range/views/slice.hpp>
 #include <seqan3/range/views/type_reduce.hpp>
 #include <seqan3/range/views/to.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/concept.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/matrix/detail/alignment_matrix_column_major_range_base.hpp b/include/seqan3/alignment/matrix/detail/alignment_matrix_column_major_range_base.hpp
index 6b43535fa7..9064da7553 100644
--- a/include/seqan3/alignment/matrix/detail/alignment_matrix_column_major_range_base.hpp
+++ b/include/seqan3/alignment/matrix/detail/alignment_matrix_column_major_range_base.hpp
@@ -12,12 +12,13 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/range.hpp>
 #include <seqan3/std/iterator>
 #include <seqan3/std/ranges>
 #include <seqan3/std/span>
 
+#include <seqan3/core/range/type_traits.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
+
 namespace seqan3::detail
 {
 
diff --git a/include/seqan3/alignment/matrix/detail/alignment_trace_matrix_proxy.hpp b/include/seqan3/alignment/matrix/detail/alignment_trace_matrix_proxy.hpp
index 3073b1deaf..ccdd752f8f 100644
--- a/include/seqan3/alignment/matrix/detail/alignment_trace_matrix_proxy.hpp
+++ b/include/seqan3/alignment/matrix/detail/alignment_trace_matrix_proxy.hpp
@@ -16,7 +16,7 @@
 
 #include <seqan3/alignment/matrix/trace_directions.hpp>
 #include <seqan3/core/simd/concept.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/matrix/detail/combined_score_and_trace_matrix.hpp b/include/seqan3/alignment/matrix/detail/combined_score_and_trace_matrix.hpp
index 2f262d36e4..27cf50199a 100644
--- a/include/seqan3/alignment/matrix/detail/combined_score_and_trace_matrix.hpp
+++ b/include/seqan3/alignment/matrix/detail/combined_score_and_trace_matrix.hpp
@@ -17,7 +17,7 @@
 #include <seqan3/alignment/matrix/detail/affine_cell_proxy.hpp>
 #include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
 #include <seqan3/core/concept/core_language.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/zip.hpp>
 
 namespace seqan3::detail
diff --git a/include/seqan3/alignment/matrix/detail/coordinate_matrix.hpp b/include/seqan3/alignment/matrix/detail/coordinate_matrix.hpp
index 0d7c33e1e5..226e3ab5ef 100644
--- a/include/seqan3/alignment/matrix/detail/coordinate_matrix.hpp
+++ b/include/seqan3/alignment/matrix/detail/coordinate_matrix.hpp
@@ -16,13 +16,13 @@
 #include <seqan3/std/ranges>
 
 #include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/core/simd/concept.hpp>
 #include <seqan3/core/simd/simd_algorithm.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
 #include <seqan3/core/simd/view_iota_simd.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
 #include <seqan3/range/container/aligned_allocator.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/matrix/detail/trace_matrix_full.hpp b/include/seqan3/alignment/matrix/detail/trace_matrix_full.hpp
index 8a4132d4b7..5f756557b5 100644
--- a/include/seqan3/alignment/matrix/detail/trace_matrix_full.hpp
+++ b/include/seqan3/alignment/matrix/detail/trace_matrix_full.hpp
@@ -21,7 +21,7 @@
 #include <seqan3/alignment/matrix/detail/two_dimensional_matrix.hpp>
 #include <seqan3/alignment/matrix/trace_directions.hpp>
 #include <seqan3/core/concept/core_language.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/range/container/aligned_allocator.hpp>
 #include <seqan3/range/views/repeat_n.hpp>
 #include <seqan3/range/views/zip.hpp>
diff --git a/include/seqan3/alignment/matrix/detail/two_dimensional_matrix.hpp b/include/seqan3/alignment/matrix/detail/two_dimensional_matrix.hpp
index 370ed8779a..687c515817 100644
--- a/include/seqan3/alignment/matrix/detail/two_dimensional_matrix.hpp
+++ b/include/seqan3/alignment/matrix/detail/two_dimensional_matrix.hpp
@@ -12,16 +12,16 @@
 
 #pragma once
 
+#include <seqan3/std/algorithm>
 #include <memory>
+#include <seqan3/std/ranges>
 #include <vector>
 
 #include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
 #include <seqan3/alignment/matrix/detail/two_dimensional_matrix_iterator_base.hpp>
-#include <seqan3/core/type_traits/deferred_crtp_base.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/ranges>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/matrix/detail/two_dimensional_matrix_iterator_base.hpp b/include/seqan3/alignment/matrix/detail/two_dimensional_matrix_iterator_base.hpp
index 750cac5783..f50fe6d35d 100644
--- a/include/seqan3/alignment/matrix/detail/two_dimensional_matrix_iterator_base.hpp
+++ b/include/seqan3/alignment/matrix/detail/two_dimensional_matrix_iterator_base.hpp
@@ -12,13 +12,13 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+#include <seqan3/std/ranges>
 #include <type_traits>
 
 #include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/align_pairwise.hpp b/include/seqan3/alignment/pairwise/align_pairwise.hpp
index 72fe6b51ec..91847cf46b 100644
--- a/include/seqan3/alignment/pairwise/align_pairwise.hpp
+++ b/include/seqan3/alignment/pairwise/align_pairwise.hpp
@@ -12,8 +12,10 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
 #include <functional>
 #include <iostream>
+#include <seqan3/std/ranges>
 #include <tuple>
 #include <type_traits>
 
@@ -28,10 +30,8 @@
 #include <seqan3/core/parallel/execution.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
 #include <seqan3/core/simd/simd.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/range/views/persist.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/alignment/pairwise/align_result_selector.hpp b/include/seqan3/alignment/pairwise/align_result_selector.hpp
index 6f7f73bf8d..5119ec0ea7 100644
--- a/include/seqan3/alignment/pairwise/align_result_selector.hpp
+++ b/include/seqan3/alignment/pairwise/align_result_selector.hpp
@@ -24,13 +24,13 @@
 #include <seqan3/alignment/pairwise/detail/type_traits.hpp>
 #include <seqan3/alphabet/gap/gapped.hpp>
 #include <seqan3/core/algorithm/configuration.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/decorator/gap_decorator.hpp>
 #include <seqan3/range/views/type_reduce.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/alignment_algorithm.hpp b/include/seqan3/alignment/pairwise/alignment_algorithm.hpp
index d6bcc5d293..86771dcdbb 100644
--- a/include/seqan3/alignment/pairwise/alignment_algorithm.hpp
+++ b/include/seqan3/alignment/pairwise/alignment_algorithm.hpp
@@ -12,8 +12,10 @@
 
 #pragma once
 
+#include <seqan3/std/iterator>
 #include <memory>
 #include <optional>
+#include <seqan3/std/ranges>
 #include <type_traits>
 
 #include <seqan3/alignment/configuration/align_config_band.hpp>
@@ -24,20 +26,17 @@
 #include <seqan3/alignment/pairwise/detail/concept.hpp>
 #include <seqan3/alignment/pairwise/detail/type_traits.hpp>
 #include <seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp>
-
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
 #include <seqan3/core/detail/empty_type.hpp>
 #include <seqan3/core/simd/concept.hpp>
 #include <seqan3/core/simd/simd.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
 #include <seqan3/core/simd/view_to_simd.hpp>
-#include <seqan3/core/type_traits/deferred_crtp_base.hpp>
-#include <seqan3/core/type_traits/function.hpp>
 #include <seqan3/range/container/aligned_allocator.hpp>
 #include <seqan3/range/views/drop.hpp>
 #include <seqan3/range/views/get.hpp>
 #include <seqan3/range/views/take.hpp>
-#include <seqan3/std/iterator>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/function_traits.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/alignment_configurator.hpp b/include/seqan3/alignment/pairwise/alignment_configurator.hpp
index 6239088d13..cbb881213b 100644
--- a/include/seqan3/alignment/pairwise/alignment_configurator.hpp
+++ b/include/seqan3/alignment/pairwise/alignment_configurator.hpp
@@ -53,12 +53,12 @@
 #include <seqan3/alignment/scoring/nucleotide_scoring_scheme.hpp>
 #include <seqan3/alignment/scoring/aminoacid_scoring_scheme.hpp>
 #include <seqan3/core/concept/tuple.hpp>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/core/simd/simd.hpp>
-#include <seqan3/core/type_traits/deferred_crtp_base.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
 #include <seqan3/range/views/type_reduce.hpp>
 #include <seqan3/range/views/zip.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/alignment_result.hpp b/include/seqan3/alignment/pairwise/alignment_result.hpp
index e84c7018e0..ad8cb14e24 100644
--- a/include/seqan3/alignment/pairwise/alignment_result.hpp
+++ b/include/seqan3/alignment/pairwise/alignment_result.hpp
@@ -17,7 +17,7 @@
 
 #include <seqan3/core/algorithm/configuration.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/detail/policy_affine_gap_recursion.hpp b/include/seqan3/alignment/pairwise/detail/policy_affine_gap_recursion.hpp
index aa474bfd72..56e6f807c9 100644
--- a/include/seqan3/alignment/pairwise/detail/policy_affine_gap_recursion.hpp
+++ b/include/seqan3/alignment/pairwise/detail/policy_affine_gap_recursion.hpp
@@ -18,7 +18,7 @@
 #include <seqan3/alignment/configuration/align_config_gap_cost_affine.hpp>
 #include <seqan3/alignment/matrix/detail/affine_cell_proxy.hpp>
 #include <seqan3/alignment/pairwise/detail/type_traits.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/core/simd/concept.hpp>
 #include <seqan3/core/simd/simd_algorithm.hpp>
 
diff --git a/include/seqan3/alignment/pairwise/detail/policy_alignment_matrix.hpp b/include/seqan3/alignment/pairwise/detail/policy_alignment_matrix.hpp
index 73262082a1..39a7fc61d8 100644
--- a/include/seqan3/alignment/pairwise/detail/policy_alignment_matrix.hpp
+++ b/include/seqan3/alignment/pairwise/detail/policy_alignment_matrix.hpp
@@ -18,7 +18,7 @@
 #include <seqan3/alignment/matrix/detail/coordinate_matrix.hpp>
 #include <seqan3/alignment/pairwise/detail/type_traits.hpp>
 #include <seqan3/core/algorithm/configuration.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/detail/policy_alignment_result_builder.hpp b/include/seqan3/alignment/pairwise/detail/policy_alignment_result_builder.hpp
index 7f1045eeb9..d6828ca9fa 100644
--- a/include/seqan3/alignment/pairwise/detail/policy_alignment_result_builder.hpp
+++ b/include/seqan3/alignment/pairwise/detail/policy_alignment_result_builder.hpp
@@ -15,7 +15,7 @@
 #include <seqan3/alignment/pairwise/detail/type_traits.hpp>
 #include <seqan3/core/algorithm/configuration.hpp>
 #include <seqan3/core/detail/empty_type.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker.hpp b/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker.hpp
index 99255a4b7a..c4862af3d1 100644
--- a/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker.hpp
+++ b/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker.hpp
@@ -20,7 +20,7 @@
 #include <seqan3/alignment/pairwise/detail/type_traits.hpp>
 #include <seqan3/core/algorithm/configuration.hpp>
 #include <seqan3/core/concept/tuple.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker_simd.hpp b/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker_simd.hpp
index 69b0770dc8..578c640f89 100644
--- a/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker_simd.hpp
+++ b/include/seqan3/alignment/pairwise/detail/policy_optimum_tracker_simd.hpp
@@ -19,8 +19,8 @@
 #include <seqan3/core/simd/simd.hpp>
 #include <seqan3/core/simd/simd_algorithm.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
 #include <seqan3/range/views/zip.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/detail/type_traits.hpp b/include/seqan3/alignment/pairwise/detail/type_traits.hpp
index cbbbd341e7..7849b506c9 100644
--- a/include/seqan3/alignment/pairwise/detail/type_traits.hpp
+++ b/include/seqan3/alignment/pairwise/detail/type_traits.hpp
@@ -12,6 +12,7 @@
 
 #pragma once
 
+#include <seqan3/std/ranges>
 #include <type_traits>
 
 #include <seqan3/alignment/configuration/align_config_result_type.hpp>
@@ -30,14 +31,13 @@
 #include <seqan3/core/algorithm/configuration.hpp>
 #include <seqan3/core/bit_manipulation.hpp>
 #include <seqan3/core/detail/empty_type.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
 #include <seqan3/core/simd/simd.hpp>
-#include <seqan3/core/type_traits/function.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
 #include <seqan3/range/views/chunk.hpp>
 #include <seqan3/range/views/zip.hpp>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/function_traits.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/edit_distance_fwd.hpp b/include/seqan3/alignment/pairwise/edit_distance_fwd.hpp
index 9e751968de..84a768bc3a 100644
--- a/include/seqan3/alignment/pairwise/edit_distance_fwd.hpp
+++ b/include/seqan3/alignment/pairwise/edit_distance_fwd.hpp
@@ -12,14 +12,15 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+#include <seqan3/std/ranges>
+
 #include <seqan3/alignment/configuration/align_config_min_score.hpp>
 #include <seqan3/alignment/pairwise/detail/type_traits.hpp>
 #include <seqan3/alignment/pairwise/align_result_selector.hpp>
 #include <seqan3/core/bit_manipulation.hpp>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
 #include <seqan3/core/platform.hpp>
-#include <seqan3/core/type_traits/deferred_crtp_base.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/policy/alignment_matrix_policy.hpp b/include/seqan3/alignment/pairwise/policy/alignment_matrix_policy.hpp
index f6fdb7ae2b..45a17bd487 100644
--- a/include/seqan3/alignment/pairwise/policy/alignment_matrix_policy.hpp
+++ b/include/seqan3/alignment/pairwise/policy/alignment_matrix_policy.hpp
@@ -17,9 +17,9 @@
 
 #include <seqan3/alignment/configuration/align_config_band.hpp>
 #include <seqan3/alignment/pairwise/detail/alignment_algorithm_state.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/range/views/slice.hpp>
 #include <seqan3/range/views/zip.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alignment/pairwise/policy/scoring_scheme_policy.hpp b/include/seqan3/alignment/pairwise/policy/scoring_scheme_policy.hpp
index 4df0701b0a..afe79f9d12 100644
--- a/include/seqan3/alignment/pairwise/policy/scoring_scheme_policy.hpp
+++ b/include/seqan3/alignment/pairwise/policy/scoring_scheme_policy.hpp
@@ -14,7 +14,7 @@
 
 #include <seqan3/alphabet/concept.hpp>
 #include <seqan3/core/simd/concept.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alphabet/aminoacid/concept.hpp b/include/seqan3/alphabet/aminoacid/concept.hpp
index 2e5b5a1cc8..3cbd44c5a3 100644
--- a/include/seqan3/alphabet/aminoacid/concept.hpp
+++ b/include/seqan3/alphabet/aminoacid/concept.hpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 // ============================================================================
 // aminoacid_empty_base
diff --git a/include/seqan3/alphabet/aminoacid/translation.hpp b/include/seqan3/alphabet/aminoacid/translation.hpp
index 669fe69786..7b62f80e85 100644
--- a/include/seqan3/alphabet/aminoacid/translation.hpp
+++ b/include/seqan3/alphabet/aminoacid/translation.hpp
@@ -17,7 +17,7 @@
 #include <seqan3/alphabet/aminoacid/aa27.hpp>
 #include <seqan3/alphabet/aminoacid/translation_genetic_code.hpp>
 #include <seqan3/alphabet/aminoacid/translation_details.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/alphabet/composite/alphabet_tuple_base.hpp b/include/seqan3/alphabet/composite/alphabet_tuple_base.hpp
index 3e3b682466..8d748cdd10 100644
--- a/include/seqan3/alphabet/composite/alphabet_tuple_base.hpp
+++ b/include/seqan3/alphabet/composite/alphabet_tuple_base.hpp
@@ -24,10 +24,10 @@
 #include <seqan3/alphabet/detail/alphabet_proxy.hpp>
 #include <seqan3/core/concept/core_language.hpp>
 #include <seqan3/core/concept/tuple.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/utility/detail/integer_traits.hpp>
 #include <seqan3/utility/type_list/traits.hpp>
 #include <seqan3/utility/type_pack/traits.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alphabet/composite/alphabet_variant.hpp b/include/seqan3/alphabet/composite/alphabet_variant.hpp
index 6fe12b62f8..4ea3cd9042 100644
--- a/include/seqan3/alphabet/composite/alphabet_variant.hpp
+++ b/include/seqan3/alphabet/composite/alphabet_variant.hpp
@@ -24,10 +24,9 @@
 
 #include <seqan3/alphabet/alphabet_base.hpp>
 #include <seqan3/alphabet/composite/detail.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
-#include <seqan3/core/type_traits/pack.hpp>
 #include <seqan3/core/tuple_utility.hpp>
 #include <seqan3/utility/type_list/traits.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
@@ -171,7 +170,7 @@ class alphabet_variant : public alphabet_base<alphabet_variant<alternative_types
     template <typename alternative_t>
     static constexpr bool holds_alternative() noexcept
     {
-        return detail::type_in_pack_v<alternative_t, alternative_types...>;
+        return seqan3::pack_traits::contains<alternative_t, alternative_types...>;
     }
 
     /*!\name Constructors, destructor and assignment
diff --git a/include/seqan3/alphabet/composite/detail.hpp b/include/seqan3/alphabet/composite/detail.hpp
index 67ea2d743c..5dfb6b3570 100644
--- a/include/seqan3/alphabet/composite/detail.hpp
+++ b/include/seqan3/alphabet/composite/detail.hpp
@@ -14,8 +14,8 @@
 
 #include <seqan3/alphabet/concept.hpp>
 #include <seqan3/core/concept/core_language.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
 #include <seqan3/utility/type_list/type_list.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/alphabet/concept.hpp b/include/seqan3/alphabet/concept.hpp
index 70f334297f..6e43e5dbb3 100644
--- a/include/seqan3/alphabet/concept.hpp
+++ b/include/seqan3/alphabet/concept.hpp
@@ -18,8 +18,8 @@
 #include <seqan3/core/concept/cereal.hpp>
 #include <seqan3/core/concept/core_language.hpp>
 #include <seqan3/core/detail/customisation_point.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/utility/detail/type_name_as_string.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 // ============================================================================
 // forwards
diff --git a/include/seqan3/alphabet/detail/alphabet_proxy.hpp b/include/seqan3/alphabet/detail/alphabet_proxy.hpp
index 7814713fb7..3ff6a6e723 100644
--- a/include/seqan3/alphabet/detail/alphabet_proxy.hpp
+++ b/include/seqan3/alphabet/detail/alphabet_proxy.hpp
@@ -12,13 +12,14 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+
 #include <seqan3/alphabet/alphabet_base.hpp>
 #include <seqan3/alphabet/nucleotide/concept.hpp>
 #include <seqan3/alphabet/quality/concept.hpp>
 #include <seqan3/core/concept/core_language.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/std/concepts>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/argument_parser/auxiliary.hpp b/include/seqan3/argument_parser/auxiliary.hpp
index 62de91e1a2..0660072472 100644
--- a/include/seqan3/argument_parser/auxiliary.hpp
+++ b/include/seqan3/argument_parser/auxiliary.hpp
@@ -12,16 +12,16 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
 #include <sstream>
+#include <seqan3/std/type_traits>
 #include <unordered_map>
 #include <vector>
 
 #include <seqan3/core/detail/customisation_point.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/io/stream/concept.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/type_traits>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::custom
 {
diff --git a/include/seqan3/argument_parser/validators.hpp b/include/seqan3/argument_parser/validators.hpp
index 572b28c934..2f384b51da 100644
--- a/include/seqan3/argument_parser/validators.hpp
+++ b/include/seqan3/argument_parser/validators.hpp
@@ -24,13 +24,13 @@
 #include <seqan3/core/concept/core_language.hpp>
 #include <seqan3/core/debug_stream/detail/to_string.hpp>
 #include <seqan3/core/detail/debug_stream_range.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/io/detail/misc.hpp>
 #include <seqan3/io/detail/safe_filesystem_entry.hpp>
 #include <seqan3/range/container/concept.hpp>
 #include <seqan3/range/views/join.hpp>
 #include <seqan3/utility/type_list/traits.hpp>
 #include <seqan3/utility/type_pack/traits.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/contrib/parallel/buffer_queue.hpp b/include/seqan3/contrib/parallel/buffer_queue.hpp
index 3d78a7fd3e..c5a16a44a2 100644
--- a/include/seqan3/contrib/parallel/buffer_queue.hpp
+++ b/include/seqan3/contrib/parallel/buffer_queue.hpp
@@ -12,23 +12,22 @@
 
 #pragma once
 
+#include <seqan3/std/algorithm>
 #include <atomic>
 #include <cmath>
+#include <seqan3/std/concepts>
 #include <mutex>
-#include <new>
+#include <seqan3/std/new>
+#include <seqan3/std/ranges>
 #include <shared_mutex>
+#include <seqan3/std/span>
 #include <type_traits>
 #include <vector>
 
 #include <seqan3/core/bit_manipulation.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/container/concept.hpp>
 #include <seqan3/utility/parallel/detail/spin_delay.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/concepts>
-#include <seqan3/std/new>
-#include <seqan3/std/ranges>
-#include <seqan3/std/span>
 
 namespace seqan3::contrib
 {
diff --git a/include/seqan3/contrib/stream/bgzf_stream_util.hpp b/include/seqan3/contrib/stream/bgzf_stream_util.hpp
index d7ac87c80d..32b71537a9 100644
--- a/include/seqan3/contrib/stream/bgzf_stream_util.hpp
+++ b/include/seqan3/contrib/stream/bgzf_stream_util.hpp
@@ -24,12 +24,13 @@
 #error "This file cannot be used when building without GZip-support."
 #endif  // SEQAN3_HAS_ZLIB
 
+#include <seqan3/std/algorithm>
+#include <seqan3/std/span>
+
 #include <seqan3/core/bit_manipulation.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/detail/magic_header.hpp>
 #include <seqan3/io/exception.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/span>
 
 namespace seqan3::contrib
 {
diff --git a/include/seqan3/core/algorithm/concept.hpp b/include/seqan3/core/algorithm/concept.hpp
index 43bfac423e..598cda93ac 100644
--- a/include/seqan3/core/algorithm/concept.hpp
+++ b/include/seqan3/core/algorithm/concept.hpp
@@ -12,13 +12,13 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
 #include <functional>
 #include <type_traits>
 
 #include <meta/meta.hpp>
 
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/std/concepts>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/core/algorithm/detail/execution_handler_parallel.hpp b/include/seqan3/core/algorithm/detail/execution_handler_parallel.hpp
index af1e778199..7a73033950 100644
--- a/include/seqan3/core/algorithm/detail/execution_handler_parallel.hpp
+++ b/include/seqan3/core/algorithm/detail/execution_handler_parallel.hpp
@@ -21,7 +21,7 @@
 
 #include <seqan3/contrib/parallel/buffer_queue.hpp>
 #include <seqan3/core/parallel/detail/reader_writer_manager.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/core/algorithm/pipeable_config_element.hpp b/include/seqan3/core/algorithm/pipeable_config_element.hpp
index 28ec6c1e95..bc23b0a47b 100644
--- a/include/seqan3/core/algorithm/pipeable_config_element.hpp
+++ b/include/seqan3/core/algorithm/pipeable_config_element.hpp
@@ -17,7 +17,7 @@
 #include <type_traits>
 
 #include <seqan3/core/algorithm/concept.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/core/all.hpp b/include/seqan3/core/all.hpp
index 287f232a6e..6b24eb0e12 100644
--- a/include/seqan3/core/all.hpp
+++ b/include/seqan3/core/all.hpp
@@ -22,9 +22,9 @@
 #include <seqan3/core/concept/all.hpp>
 #include <seqan3/core/debug_stream.hpp>
 #include <seqan3/core/detail/all.hpp>
-#include <seqan3/core/type_traits/all.hpp>
 #include <seqan3/core/platform.hpp>
 #include <seqan3/core/pod_tuple.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/core/tuple_utility.hpp>
 
 /*!\defgroup core Core
diff --git a/include/seqan3/core/char_operations/predicate_detail.hpp b/include/seqan3/core/char_operations/predicate_detail.hpp
index b6569b4c98..858d8298d9 100644
--- a/include/seqan3/core/char_operations/predicate_detail.hpp
+++ b/include/seqan3/core/char_operations/predicate_detail.hpp
@@ -20,8 +20,8 @@
 #include <string>
 
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/utility/detail/type_name_as_string.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/core/concept/tuple.hpp b/include/seqan3/core/concept/tuple.hpp
index 6b7747a0d3..7a9730d16f 100644
--- a/include/seqan3/core/concept/tuple.hpp
+++ b/include/seqan3/core/concept/tuple.hpp
@@ -16,10 +16,10 @@
 #include <tuple>
 #include <type_traits>
 
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/core/pod_tuple.hpp>
 #include <seqan3/utility/type_list/type_list.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/core/detail/all.hpp b/include/seqan3/core/detail/all.hpp
index cdde8dfb4d..7a662b9fc3 100644
--- a/include/seqan3/core/detail/all.hpp
+++ b/include/seqan3/core/detail/all.hpp
@@ -20,6 +20,7 @@
 #include <seqan3/core/detail/debug_stream_tuple.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
 #include <seqan3/core/detail/debug_stream_variant.hpp>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
+#include <seqan3/core/detail/iterator_traits.hpp>
 #include <seqan3/core/detail/strong_type.hpp>
-#include <seqan3/utility/detail/integer_traits.hpp>
-#include <seqan3/utility/detail/type_name_as_string.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
diff --git a/include/seqan3/core/detail/debug_stream_optional.hpp b/include/seqan3/core/detail/debug_stream_optional.hpp
index 9b60a8d022..f61b1ecf05 100644
--- a/include/seqan3/core/detail/debug_stream_optional.hpp
+++ b/include/seqan3/core/detail/debug_stream_optional.hpp
@@ -15,8 +15,8 @@
 #include <optional>
 
 #include <seqan3/core/detail/debug_stream_type.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/core/detail/debug_stream_range.hpp b/include/seqan3/core/detail/debug_stream_range.hpp
index 6f81cc3057..af19e29ad7 100644
--- a/include/seqan3/core/detail/debug_stream_range.hpp
+++ b/include/seqan3/core/detail/debug_stream_range.hpp
@@ -18,7 +18,7 @@
 #include <seqan3/alphabet/adaptation/uint.hpp>
 #include <seqan3/alphabet/concept.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/concept.hpp>
 
 namespace seqan3::detail
diff --git a/include/seqan3/core/detail/debug_stream_variant.hpp b/include/seqan3/core/detail/debug_stream_variant.hpp
index 8dca90cf25..c6c92cd51e 100644
--- a/include/seqan3/core/detail/debug_stream_variant.hpp
+++ b/include/seqan3/core/detail/debug_stream_variant.hpp
@@ -15,8 +15,8 @@
 #include <variant>
 
 #include <seqan3/core/detail/debug_stream_type.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/core/detail/deferred_crtp_base.hpp b/include/seqan3/core/detail/deferred_crtp_base.hpp
new file mode 100644
index 0000000000..bd4523217a
--- /dev/null
+++ b/include/seqan3/core/detail/deferred_crtp_base.hpp
@@ -0,0 +1,101 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides seqan3::detail::deferred_crtp_base.
+ * \author Rene Rahn <rene.rahn AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <seqan3/core/platform.hpp>
+
+namespace seqan3::detail
+{
+
+/*!\brief An invocable wrapper that defers the instantiation of a crtp_base class.
+ * \ingroup core
+ * \tparam crtp_base The crtp base class to be deferred. Must be a template template parameter.
+ * \tparam args_t    A type template parameter pack used to augment the `crtp_base` class.
+ *
+ * \details
+ *
+ * This transformation trait wrapper allows to defer the template instantiation of crtp-base classes. This can be useful
+ * if the crtp_base class should be augmented with traits or other templates, especially when using variadic
+ * crtp_bases. The help function seqan3::detail::invoke_deferred_crtp_base can be used to instantiate the
+ * deferred crtp base with the respective derived type.
+ *
+ * ### Example
+ *
+ * The following snippet demonstrates the use of the deferred crtp base class instantiation.
+ *
+ * \include test/snippet/core/detail/deferred_crtp_base.cpp
+ *
+ * \see seqan3::detail::invoke_deferred_crtp_base
+ * \see seqan3::detail::deferred_crtp_base_vargs
+ */
+template <template <typename ...> typename crtp_base, typename ...args_t>
+struct deferred_crtp_base
+{
+    /*!\brief Invokes the deferred crtp_base with the corresponding derived type.
+     * \tparam derived_t The derived type to instantiate the crtp_base with.
+     */
+    template <typename derived_t>
+    using invoke = crtp_base<derived_t, args_t...>;
+};
+
+/*!\brief An invocable wrapper that defers the instantiation of a crtp_base class.
+ * \ingroup core
+ * \tparam crtp_base The crtp base class to be deferred. Must be a template template parameter.
+ * \tparam args      A non-type template parameter pack used to augment the `crtp_base` class.
+ *
+ * \details
+ *
+ * This transformation trait wrapper allows to defer the template instantiation of crtp-base classes. This can be useful
+ * if the crtp_base class should be augmented with traits or other templates, especially when using variadic
+ * crtp_bases. The help function seqan3::detail::invoke_deferred_crtp_base can be used to instantiate the
+ * deferred crtp base with the respective derived type. This class wrapper can only be used to augment a crtp-base
+ * class with non-type arguments. See seqan3::detail::deferred_crtp_base for a version that accepts type template
+ * parameters.
+ *
+ * ### Example
+ *
+ * The following snippet demonstrates the use of the deferred crtp base class instantiation.
+ *
+ * \include test/snippet/core/detail/deferred_crtp_base.cpp
+ *
+ * \see seqan3::detail::invoke_deferred_crtp_base
+ * \see seqan3::detail::deferred_crtp_base
+ */
+template <template <typename, auto ...> typename crtp_base, auto ...args>
+struct deferred_crtp_base_vargs
+{
+    /*!\brief Invokes the deferred crtp_base with the corresponding derived type.
+     * \tparam derived_t The derived type to instantiate the crtp_base with.
+     */
+    template <typename derived_t>
+    using invoke = crtp_base<derived_t, args...>;
+};
+
+/*!\brief Template alias to instantiate the deferred crtp base with the derived class.
+ * \ingroup core
+ * \tparam deferred_crtp_base_t The deferred crtp base class.
+ * \tparam derived_t            The derived type to instantiate the crtp base class with.
+ *
+ * \details
+ *
+ * Effectively declares the type resulting from `deferred_crtp_base_t::template invoke<derived_t>`.
+ *
+ * \see seqan3::detail::deferred_crtp_base
+ */
+template <typename deferred_crtp_base_t, typename derived_t>
+//!\cond
+    requires requires { typename deferred_crtp_base_t::template invoke<derived_t>; }
+//!\endcond
+using invoke_deferred_crtp_base = typename deferred_crtp_base_t::template invoke<derived_t>;
+
+} // namespace seqan3::detail
diff --git a/include/seqan3/core/detail/is_class_template_declarable.hpp b/include/seqan3/core/detail/is_class_template_declarable.hpp
new file mode 100644
index 0000000000..d9e8a13e3e
--- /dev/null
+++ b/include/seqan3/core/detail/is_class_template_declarable.hpp
@@ -0,0 +1,69 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides a type trait for verifying valid template declarations.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <seqan3/std/type_traits>
+
+#include <seqan3/core/platform.hpp>
+
+namespace seqan3::detail
+{
+
+/*!\addtogroup core
+ * \{
+ */
+
+/*!\brief An unary type trait that tests whether a template class can be declared with the given template type
+ *        parameters.
+ * \implements seqan3::unary_type_trait
+ * \tparam query_t The type of the template class to test.
+ * \tparam args_t  The template parameter pack to instantiate the template class with.
+ *
+ * \details
+ *
+ * Note, this unary type trait can be used in a seqan3::detail::lazy_conditional expression to check if instantiating
+ * a template class with specific template arguments would result in a valid template declaration. Thus, the template
+ * parameters of the checked class must be constrained accordingly. It is, however, not possible to test if the
+ * the resulting type is incomplete or not, such that it can not be tested if an instance of the class template with
+ * the given template arguments can be actually created.
+ *
+ * ### Example
+ *
+ * \include test/snippet/core/detail/is_class_template_declarable_with.cpp
+ */
+template <template <typename ...> typename query_t, typename ...args_t>
+struct is_class_template_declarable_with :
+//!\cond
+    public std::false_type
+//!\endcond
+{};
+
+//!\cond
+template <template <typename ...> typename query_t, typename ...args_t>
+requires requires { typename std::type_identity<query_t<args_t...>>::type; }
+struct is_class_template_declarable_with<query_t, args_t...> : public std::true_type
+{};
+//!\endcond
+
+/*!\brief Helper variable template for seqan3::detail::is_class_template_declarable_with.
+ * \tparam query_t The type of the template class to test.
+ * \tparam args_t  The template parameter pack to instantiate the template class with.
+ * \relates seqan3::detail::is_class_template_declarable_with
+ */
+template <template <typename ...> typename query_t, typename ...args_t>
+inline constexpr bool is_class_template_declarable_with_v =
+    is_class_template_declarable_with<query_t, args_t...>::value;
+
+//!\}
+
+} // namespace seqan3::detail
diff --git a/include/seqan3/core/detail/iterator_traits.hpp b/include/seqan3/core/detail/iterator_traits.hpp
new file mode 100644
index 0000000000..f9ecacdeb3
--- /dev/null
+++ b/include/seqan3/core/detail/iterator_traits.hpp
@@ -0,0 +1,272 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides various transformation traits for use on iterators.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <seqan3/std/iterator>
+#include <type_traits>
+
+#include <seqan3/core/platform.hpp>
+#include <seqan3/utility/type_traits/pre.hpp>
+
+namespace seqan3
+{
+
+/*!\addtogroup core
+ * \{
+ */
+
+// ----------------------------------------------------------------------------
+// value_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `value_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type you wish to query; must model std::input_iterator.
+ * \deprecated This is deprecated use std::iter_value_t.
+ */
+template <std::input_iterator it_t>
+struct value_type<it_t>
+{
+    //!\brief Return the member type as return type.
+    using type = std::iter_value_t<it_t>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// see specialisation for ranges in core/range/type_traits.hpp
+
+// ----------------------------------------------------------------------------
+// reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `reference` type of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type you wish to query; must model std::input_iterator.
+ * \deprecated This is deprecated use std::iter_reference_t.
+ */
+template <std::input_iterator it_t>
+struct reference<it_t>
+{
+    //!\brief Return the member type as return type.
+    using type = std::iter_reference_t<it_t>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// see specialisation for ranges in core/range/type_traits.hpp
+
+// ----------------------------------------------------------------------------
+// rvalue_reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `rvalue_reference` type of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type you wish to query; must model std::input_iterator.
+ * \deprecated This is deprecated use std::iter_rvalue_reference_t.
+ */
+template <std::input_iterator it_t>
+struct rvalue_reference<it_t>
+{
+    //!\brief Return the member type as return type.
+    using type = std::iter_rvalue_reference_t<it_t>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// see specialisation for ranges in core/range/type_traits.hpp
+
+// ----------------------------------------------------------------------------
+// const_reference
+// ----------------------------------------------------------------------------
+
+// only defined for ranges
+
+// ----------------------------------------------------------------------------
+// difference_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `difference_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type you wish to query; must model std::weakly_incrementable.
+ * \deprecated This is deprecated use std::iter_difference_t.
+ */
+template <std::weakly_incrementable it_t>
+struct difference_type<it_t>
+{
+    //!\brief Return the member type as return type.
+    using type = std::iter_difference_t<it_t>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// see specialisation for ranges in core/range/type_traits.hpp
+
+// ----------------------------------------------------------------------------
+// size_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `size_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type you wish to query; must model std::weakly_incrementable.
+ * \deprecated This is deprecated. There is no alternative! Unlike std::ranges::range_size_t, the Standard has no
+ *            std::iter_size_t. We decided that it does not make sense to define it on the difference type of the
+ *            iterator.
+ */
+template <std::weakly_incrementable it_t>
+struct size_type<it_t>
+{
+    //!\brief Return the member type as return type.
+    using type = std::make_unsigned_t<std::iter_difference_t<it_t>>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// see specialisation for ranges in core/range/type_traits.hpp
+//!\}
+
+} // namespace seqan3
+
+namespace seqan3::detail
+{
+#if SEQAN3_WORKAROUND_GCC_96070
+//!\cond
+template <typename it_t>
+struct iterator_category_tag
+{
+    using type = void;
+};
+
+template <typename it_t>
+    requires requires { typename std::iterator_traits<it_t>::iterator_category; }
+struct iterator_category_tag<it_t>
+{
+    using type = typename std::iterator_traits<it_t>::iterator_category;
+};
+//!\endcond
+/*!\brief Exposes the
+ * [iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_tags) from the modelled concept.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type to operate on.
+ *
+ * \attention
+ * If [std::iterator_traits<it_t>::iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_traits)
+ * is defined for a type `it_t`, this transformation trait acts as an alias for it, if not it is `void`.
+ */
+template <typename it_t>
+using iterator_category_tag_t = typename iterator_category_tag<it_t>::type;
+#else // ^^^ workaround / no workaround vvv
+// TODO: Change the description / the definition of iterator_category_tag_t depending on how the standard resolves this
+// https://github.com/seqan/product_backlog/issues/151
+
+/*!\brief Exposes the
+ * [iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_tags) from the modelled concept.
+ * \tparam it_t The type to operate on.
+ *
+ * \attention
+ * If [std::iterator_traits<it_t>::iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_traits)
+ * is defined for a type `it_t`, this transformation trait acts as an alias for it.
+ *
+ * If not, this means that `it_t` is no "legacy" iterator and this transformation trait will give a substitution error.
+ */
+template <typename it_t>
+//!\cond
+    requires requires { typename std::iterator_traits<it_t>::iterator_category; }
+//!\endcond
+using iterator_category_tag_t = typename std::iterator_traits<it_t>::iterator_category;
+#endif // SEQAN3_WORKAROUND_GCC_96070
+
+/*!\brief Exposes the
+ * [iterator_concept](https://en.cppreference.com/w/cpp/iterator/iterator_tags) from the modelled concept.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type to operate on.
+ */
+template <typename it_t>
+//!\cond
+    requires std::input_or_output_iterator<it_t>
+//!\endcond
+using iterator_concept_tag_t =
+    std::conditional_t<
+        std::contiguous_iterator<it_t>,
+        std::contiguous_iterator_tag,
+        std::conditional_t<
+            std::random_access_iterator<it_t>,
+            std::random_access_iterator_tag,
+            std::conditional_t<
+                std::bidirectional_iterator<it_t>,
+                std::bidirectional_iterator_tag,
+                std::conditional_t<
+                    std::forward_iterator<it_t>,
+                    std::forward_iterator_tag,
+                    std::conditional_t<
+                        std::input_iterator<it_t>,
+                        std::input_iterator_tag,
+                        std::output_iterator_tag>>>>>;
+
+} // namespace seqan3::detail
+
+namespace seqan3::detail
+{
+// ----------------------------------------------------------------------------
+// iter_pointer
+// ----------------------------------------------------------------------------
+
+/*!\brief This is like std::iter_value_t, but for the pointer type.
+ * \implements seqan3::transformation_trait
+ * \tparam it_t The type to operate on.
+ * \see seqan3::detail::iter_pointer_t
+ *
+ * \attention
+ * C++20 does not provide a `std::iter_pointer_t`, because the new C++20 iterators do not need to provide a pointer
+ * type.
+ */
+template <typename it_t>
+struct iter_pointer
+{
+    //!\brief The pointer type of std::iterator_traits or void.
+    using type = void;
+};
+
+//!\cond
+template <typename it_t>
+    requires requires { typename std::iterator_traits<it_t>::pointer; }
+struct iter_pointer<it_t>
+{
+    //!\brief This is defined for every legacy input-iterator.
+    //!\sa https://en.cppreference.com/w/cpp/iterator/iterator_traits
+    using type = typename std::iterator_traits<it_t>::pointer;
+};
+//!\endcond
+
+/*!\brief Return the `pointer` type of the input type (transformation_trait shortcut).
+ * \tparam it_t The type to operate on.
+ * \see seqan3::detail::iter_pointer
+ */
+template <typename it_t>
+using iter_pointer_t = typename iter_pointer<it_t>::type;
+
+} // namespace seqan3::detail
diff --git a/include/seqan3/core/detail/strong_type.hpp b/include/seqan3/core/detail/strong_type.hpp
index 36e45c8297..d707706814 100644
--- a/include/seqan3/core/detail/strong_type.hpp
+++ b/include/seqan3/core/detail/strong_type.hpp
@@ -17,7 +17,7 @@
 
 #include <seqan3/core/add_enum_bitwise_operators.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/core/detail/template_inspection.hpp b/include/seqan3/core/detail/template_inspection.hpp
new file mode 100644
index 0000000000..83309d7a51
--- /dev/null
+++ b/include/seqan3/core/detail/template_inspection.hpp
@@ -0,0 +1,249 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ * \brief Provides type traits for working with templates.
+ */
+
+#pragma once
+
+#include <seqan3/std/concepts>
+
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
+
+namespace seqan3::detail
+{
+
+// ----------------------------------------------------------------------------
+// transfer_template_args_onto
+// ----------------------------------------------------------------------------
+
+//!\cond
+template <typename source_type, template <typename ...> typename target_template>
+struct transfer_template_args_onto
+{};
+//!\endcond
+
+/*!\brief Extracts a type template's **type** arguments and specialises another template with them.
+ * \implements seqan3::transformation_trait
+ * \ingroup core
+ * \tparam source_template   The source type; must be a specialisation of a template.
+ * \tparam target_template   The type template you wish to specialise.
+ * \tparam source_arg_types  The **type** arguments to the source_template (deduced implicitly).
+ * \see seqan3::detail::transfer_template_vargs_onto
+ *
+ * \details
+ *
+ * Among other use cases, it enables using the types contained in a seqan3::type_list to specialise another type
+ * template.
+ *
+ * A type trait shortcut is also defined: seqan3::detail::transfer_template_args_onto_t
+ *
+ * This type trait works for templates that have **only type-arguments**. See
+ * seqan3::detail::transfer_template_vargs_onto for a type trait that transfers non-type arguments. There is
+ * no type trait that can handle a combination of type and non-type arguments.
+ * If the `source_type` is a not a template class, e.g. an `int`, the member type `type` is not defined.
+ *
+ * ### Example
+ *
+ * \include test/snippet/core/detail/template_inspection_usage.cpp
+ */
+template <template <typename ...> typename source_template,
+          template <typename ...> typename target_template,
+          typename ...source_arg_types>
+//!\cond
+    requires requires ()
+    {
+        typename target_template<source_arg_types...>;
+    }
+//!\endcond
+struct transfer_template_args_onto<source_template<source_arg_types...>, target_template>
+{
+    //!\brief The return type: the target type specialised by the unpacked types in the list.
+    using type = target_template<source_arg_types...>;
+};
+
+/*!\brief Shortcut for seqan3::detail::transfer_template_args_onto (transformation_trait shortcut).
+ * \ingroup core
+ * \see seqan3::detail::transfer_template_args_onto
+ */
+template <typename source_type, template <typename ...> typename target_template>
+using transfer_template_args_onto_t = typename transfer_template_args_onto<source_type, target_template>::type;
+
+// ----------------------------------------------------------------------------
+// transfer_template_vargs_onto
+// ----------------------------------------------------------------------------
+
+//!\cond
+template <typename source_type, template <auto ...> typename target_template>
+struct transfer_template_vargs_onto
+{};
+//!\endcond
+
+/*!\brief Extracts a type template's **non-type** arguments and specialises another template with them.
+ * \implements seqan3::transformation_trait
+ * \ingroup core
+ * \tparam source_template   The source type; must be a specialisation of a template.
+ * \tparam target_template   The type template you wish to specialise.
+ * \tparam source_varg_types The **non-type** arguments to the source_template (deduced implicitly).
+ * \see seqan3::detail::transfer_template_vargs_onto
+ *
+ * \details
+ *
+ * A shortcut is also defined: seqan3::detail::transfer_template_vargs_onto_t
+ *
+ * This transformation trait works for templates that have **only non-type-arguments**. See
+ * seqan3::detail::transfer_template_args_onto for a transformation trait that transfers type arguments. There is
+ * no transformation trait that can handle a combination of type and non-type arguments.
+ * If the `source_type` is a not a template class, e.g. an `int`, the member type `type` is not defined.
+ */
+template <template <auto ...> typename source_template,
+          template <auto ...> typename target_template,
+          auto ... source_varg_types>
+//!\cond
+    requires requires ()
+    {
+        typename target_template<source_varg_types...>;
+    }
+//!\endcond
+struct transfer_template_vargs_onto<source_template<source_varg_types...>, target_template>
+{
+    //!\brief The return type: the target type specialised by the unpacked types in the list.
+    using type = target_template<source_varg_types...>;
+};
+
+/*!\brief Shortcut for seqan3::detail::transfer_template_vargs_onto (transformation_trait shortcut).
+ * \ingroup core
+ * \see seqan3::detail::transfer_template_vargs_onto
+ */
+template <typename source_type, template <auto ...> typename target_template>
+using transfer_template_vargs_onto_t = typename transfer_template_vargs_onto<source_type, target_template>::type;
+
+// ----------------------------------------------------------------------------
+// is_type_specialisation_of_v
+// ----------------------------------------------------------------------------
+
+/*!\brief Determines whether a source_type is a specialisation of another template.
+ * \implements seqan3::unary_type_trait
+ * \ingroup core
+ * \tparam source_type      The source type.
+ * \tparam target_template  The type template you wish to compare against (must take only types as template arguments).
+ *
+ * \details
+ *
+ * ### Example
+ *
+ * \include test/snippet/core/detail/template_inspection_usage_2.cpp
+ */
+template <typename source_t, template <typename ...> typename target_template>
+struct is_type_specialisation_of : public std::false_type
+{};
+
+//!\overload
+template <typename source_t, template <typename ...> typename target_template>
+//!\cond
+    requires (!std::same_as<transformation_trait_or_t<transfer_template_args_onto<source_t, target_template>, void>,
+                            void>)
+//!\endcond
+struct is_type_specialisation_of<source_t, target_template> :
+        std::is_same<source_t, transfer_template_args_onto_t<source_t, target_template>>
+{};
+
+/*!\brief Helper variable template for seqan3::detail::is_type_specialisation_of (unary_type_trait shortcut).
+ * \relates seqan3::detail::is_type_specialisation_of
+ * \tparam source_type      The source type.
+ * \tparam target_template  The type template you wish to compare against (must take only types as template arguments).
+ */
+template <typename source_t, template <typename ...> typename target_template>
+inline constexpr bool is_type_specialisation_of_v = is_type_specialisation_of<source_t, target_template>::value;
+
+// ----------------------------------------------------------------------------
+// is_value_specialisation_of_v
+// ----------------------------------------------------------------------------
+
+//!\cond
+template <typename source_t, template <auto ...> typename target_template>
+struct is_value_specialisation_of : std::false_type
+{};
+//!\endcond
+
+/*!\brief Determines whether a source_type is a specialisation of another template.
+ * \implements seqan3::unary_type_trait
+ * \ingroup core
+ * \tparam source_type      The source type.
+ * \tparam target_template  The type template you wish to compare against (must take only non-types as template
+ * arguments).
+ * \see seqan3::detail::is_type_specialisation_of
+ * \see seqan3::detail::is_value_specialisation_of_v
+ */
+template <typename source_t, template <auto ...> typename target_template>
+//!\cond
+    requires (!std::same_as<transformation_trait_or_t<transfer_template_vargs_onto<source_t, target_template>, void>,
+                            void>)
+//!\endcond
+struct is_value_specialisation_of<source_t, target_template> :
+    std::is_same<source_t, transfer_template_vargs_onto_t<source_t, target_template>>
+{};
+
+/*!\brief Helper variable template for seqan3::detail::is_value_specialisation_of (unary_type_trait shortcut).
+ * \relates seqan3::detail::is_value_specialisation_of
+ * \tparam source_type      The source type.
+ * \tparam target_template  The type template you wish to compare against (must take only types as template arguments).
+ */
+template <typename source_t, template <auto ...> typename target_template>
+inline constexpr bool is_value_specialisation_of_v = is_value_specialisation_of<source_t, target_template>::value;
+
+/*!
+ * \brief Exposes `templ_t<spec_t...>` if that is valid, otherwise `fallback_t`.
+ * \implements seqan3::transformation_trait
+ * \see seqan3::detail::valid_template_spec_or_t
+ * \ingroup core
+ * \tparam fallback_t The fallback type.
+ * \tparam templ_t    The type template that should be specialised.
+ * \tparam spec_t     The specialisation for the type template.
+ */
+template <typename fallback_t, template <typename ...> typename templ_t, typename ...spec_t>
+struct valid_template_spec_or
+{
+    //!\brief The resulting type.
+    using type = fallback_t;
+};
+
+//!\overload
+template <typename fallback_t, template <typename ...> typename templ_t, typename ...spec_t>
+//!\cond
+    requires requires { typename templ_t<spec_t...>; }
+//!\endcond
+struct valid_template_spec_or<fallback_t, templ_t, spec_t...>
+{
+    //!\brief The resulting type.
+    using type = templ_t<spec_t...>;
+};
+
+/*!\brief Helper for seqan3::detail::valid_template_spec_or (transformation_trait shortcut).
+ * \ingroup core
+ * \see seqan3::detail::valid_template_spec_or
+ * \tparam fallback_t The fallback type.
+ * \tparam templ_t    The type template that should be specialised.
+ * \tparam spec_t     The specialisation for the type template.
+ */
+template <typename fallback_t, template <typename ...> typename templ_t, typename ...spec_t>
+using valid_template_spec_or_t = typename valid_template_spec_or<fallback_t, templ_t, spec_t...>::type;
+
+// ----------------------------------------------------------------------------
+// strip_type_identity
+// ----------------------------------------------------------------------------
+
+/*!\brief A transformation trait shortcut that returns the type inside a std::type_identity or the type itself.
+ * \tparam t The type to operate on.
+ */
+template <typename t>
+using strip_type_identity_t = std::conditional_t<is_type_specialisation_of_v<t, std::type_identity>,
+                                                 transformation_trait_or_t<t, void>,
+                                                 t>;
+} // namespace seqan3::detail
diff --git a/include/seqan3/core/range/type_traits.hpp b/include/seqan3/core/range/type_traits.hpp
new file mode 100644
index 0000000000..cb9aa0cc77
--- /dev/null
+++ b/include/seqan3/core/range/type_traits.hpp
@@ -0,0 +1,287 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides various transformation traits used by the range module.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <seqan3/std/iterator>
+#include <seqan3/std/ranges>
+#include <type_traits>
+
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/platform.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/pre.hpp>
+
+// TODO(h-2): add innermost_reference instead of or addition to range_innermost_value?
+
+//NOTE(h-2): for the range overloads we explicitly forbid that the type is iteratoer
+// because some types are actually both (e.g. std::directory_iterator)
+
+namespace seqan3::detail
+{
+
+//!\cond
+template <typename t>
+SEQAN3_CONCEPT has_range_value_type = requires { typename std::ranges::range_value_t<std::remove_cvref_t<t>>; };
+//!\endcond
+
+//!\brief Makes range_t const if const_range is true; otherwise keeps range_t as is.
+//!\ingroup core
+template <bool const_range, typename range_t>
+using maybe_const_range_t = std::conditional_t<const_range, range_t const, range_t>;
+
+//!\brief Returns the const iterator of range_t if const_range is true; otherwise the non-const iterator.
+//!\ingroup core
+template <bool const_range, typename range_t>
+using maybe_const_iterator_t = std::ranges::iterator_t<maybe_const_range_t<const_range, range_t>>;
+
+//!\brief Returns the const sentinel of range_t if const_range is true; otherwise the non-const sentinel.
+//!\ingroup core
+template <bool const_v, typename range_t>
+using maybe_const_sentinel_t = std::ranges::sentinel_t<maybe_const_range_t<const_v, range_t>>;
+} // namespace seqan3::detail
+
+namespace seqan3
+{
+
+/*!\addtogroup core
+ * \{
+ */
+
+// ----------------------------------------------------------------------------
+// value_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `value_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query; must model std::ranges::input_range.
+ * \deprecated This is deprecated use std::ranges::range_value_t.
+ */
+template <std::ranges::input_range rng_t>
+//!\cond
+    requires (!std::input_or_output_iterator<rng_t>)
+//!\endcond
+struct value_type<rng_t>
+{
+    //!\brief Return the value_type member definition from the queried type's iterator.
+    using type = value_type_t<std::ranges::iterator_t<rng_t>>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// ----------------------------------------------------------------------------
+// reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `reference` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query; must model std::ranges::input_range.
+ * \deprecated This is deprecated use std::ranges::range_reference_t.
+ */
+template <std::ranges::input_range rng_t>
+//!\cond
+    requires (!std::input_or_output_iterator<rng_t>)
+//!\endcond
+struct reference<rng_t>
+{
+    //!\brief Return the reference member definition from the queried type's iterator.
+    using type = reference_t<std::ranges::iterator_t<rng_t>>;
+};
+ } // namespace seqan3::detail
+ #endif // SEQAN3_DEPRECATED_310
+
+// ----------------------------------------------------------------------------
+// rvalue_reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `rvalue_reference` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query; must model std::ranges::input_range.
+ * \deprecated This is deprecated use std::ranges::range_rvalue_reference_t.
+ */
+template <std::ranges::input_range rng_t>
+//!\cond
+    requires (!std::input_or_output_iterator<rng_t>)
+//!\endcond
+struct rvalue_reference<rng_t>
+{
+    //!\brief Return the rvalue_reference member definition from the queried type's iterator.
+    using type = rvalue_reference_t<std::ranges::iterator_t<rng_t>>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// ----------------------------------------------------------------------------
+// const_reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `const_reference` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query; must model std::ranges::input_range.
+ * \deprecated This is deprecated use std::ranges::range_reference_t<rng_t const>.
+ */
+template <std::ranges::input_range rng_t>
+//!\cond
+    requires (!std::input_or_output_iterator<rng_t>)
+//!\endcond
+struct const_reference<rng_t>
+{
+    //!\brief Resolves to the reference type of the `const_iterator` of t (not the `const iterator`!).
+    using type = std::iter_reference_t<std::ranges::iterator_t<rng_t const>>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// ----------------------------------------------------------------------------
+// difference_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `difference_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query; must model std::ranges::input_range.
+ * \deprecated This is deprecated use std::ranges::range_difference_t.
+ */
+template <std::ranges::range rng_t>
+//!\cond
+    requires (!std::input_or_output_iterator<rng_t>)
+//!\endcond
+struct difference_type<rng_t>
+{
+    //!\brief Return the difference_type member definition from the queried type's iterator.
+    using type = difference_type_t<std::ranges::iterator_t<rng_t>>;
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// ----------------------------------------------------------------------------
+// size_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+/*!\brief Exposes the `size_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query; must model std::ranges::sized_range.
+ * \deprecated This is deprecated use std::ranges::range_size_t.
+ */
+template <std::ranges::sized_range rng_t>
+//!\cond
+    requires (!std::input_or_output_iterator<rng_t>)
+//!\endcond
+struct size_type<rng_t>
+{
+    //!\brief Return the size_type as returned by the size function.
+    using type = decltype(std::ranges::size(std::declval<rng_t &>()));
+};
+} // namespace seqan3::detail
+#endif // SEQAN3_DEPRECATED_310
+
+// ----------------------------------------------------------------------------
+// range_innermost_value
+// ----------------------------------------------------------------------------
+
+//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
+
+/*!\brief Recursively determines the `value_type` on containers and/or iterators.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type to recurse on; must have `std::ranges::value_type_t<rng_t>`.
+ *
+ * \details
+ *
+ * Attention, this transformation trait implicitly removes cv-qualifiers on all value_types except the one returned.
+ */
+template <typename t>
+//!\cond
+    requires detail::has_range_value_type<t>
+//!\endcond
+struct range_innermost_value
+{
+    //!\brief The return type (recursion not shown).
+    using type = std::ranges::range_value_t<std::remove_cvref_t<t>>;
+};
+
+//!\cond
+template <typename t>
+    requires detail::has_range_value_type<t> && detail::has_range_value_type<std::ranges::range_value_t<std::remove_cvref_t<t>>>
+struct range_innermost_value<t>
+{
+    using type = typename range_innermost_value<std::ranges::range_value_t<std::remove_cvref_t<t>>>::type;
+};
+//!\endcond
+
+//!\brief Shortcut for seqan3::range_innermost_value (transformation_trait shortcut).
+//!\see seqan3::range_innermost_value
+template <typename t>
+using range_innermost_value_t = typename range_innermost_value<t>::type;
+
+// ----------------------------------------------------------------------------
+// range_dimension_v
+// ----------------------------------------------------------------------------
+
+//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
+
+/*!\brief Returns the number of times you can call `seqan3::value_type_t` recursively on t (type trait).
+ * \tparam t The type to be queried; must resolve `seqan3::value_type_t` at least once.
+ *
+ * \details
+ *
+ * Attention, this type trait implicitly removes cv-qualifiers and reference from the types it recurses on and
+ * returns.
+ */
+template <typename t>
+//!\cond
+    requires detail::has_range_value_type<t>
+//!\endcond
+constexpr size_t range_dimension_v = 1;
+
+//!\cond
+template <typename t>
+    requires detail::has_range_value_type<t> && detail::has_range_value_type<std::ranges::range_value_t<std::remove_cvref_t<t>>>
+constexpr size_t range_dimension_v<t> = range_dimension_v<std::ranges::range_value_t<std::remove_cvref_t<t>>> + 1;
+//!\endcond
+
+// ----------------------------------------------------------------------------
+// range_compatible [DEPRECATED]
+// ----------------------------------------------------------------------------
+
+/*!\interface seqan3::range_compatible <>
+ * \brief Two types are "compatible" if their seqan3::range_dimension_v and their seqan3::range_innermost_value_t are
+ * the same.
+ * \deprecated This concept is deprecated and will be removed in SeqAn-3.1.
+ */
+//!\cond
+template <typename t1, typename t2>
+SEQAN3_DEPRECATED_310 constexpr bool range_compatible = (
+    std::is_same_v<range_innermost_value_t<t1>, range_innermost_value_t<t2>> &&
+    range_dimension_v<t1> == range_dimension_v<t2>
+);
+//!\endcond
+
+//!\}
+
+} // namespace seqan3
diff --git a/include/seqan3/core/simd/detail/builtin_simd.hpp b/include/seqan3/core/simd/detail/builtin_simd.hpp
index dbbcf6deb9..866a0d4bb8 100644
--- a/include/seqan3/core/simd/detail/builtin_simd.hpp
+++ b/include/seqan3/core/simd/detail/builtin_simd.hpp
@@ -16,10 +16,10 @@
 #include <type_traits>
 
 #include <seqan3/core/bit_manipulation.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/core/simd/detail/default_simd_length.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
 #include <seqan3/utility/detail/integer_traits.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/core/simd/view_to_simd.hpp b/include/seqan3/core/simd/view_to_simd.hpp
index ae55e25a45..ca1ddea950 100644
--- a/include/seqan3/core/simd/view_to_simd.hpp
+++ b/include/seqan3/core/simd/view_to_simd.hpp
@@ -12,20 +12,21 @@
 
 #pragma once
 
+#include <seqan3/std/algorithm>
+#include <seqan3/std/iterator>
+#include <seqan3/std/ranges>
+
 #include <seqan3/alphabet/concept.hpp>
 #include <seqan3/core/detail/pack_algorithm.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/core/simd/concept.hpp>
 #include <seqan3/core/simd/simd_algorithm.hpp>
 #include <seqan3/core/simd/simd_traits.hpp>
 #include <seqan3/core/simd/simd.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
 #include <seqan3/range/views/detail.hpp>
 #include <seqan3/range/views/type_reduce.hpp>
 #include <seqan3/range/views/zip.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/iterator>
-#include <seqan3/std/ranges>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/core/type_traits/all.hpp b/include/seqan3/core/type_traits/all.hpp
index ab9c69a73c..09f6153654 100644
--- a/include/seqan3/core/type_traits/all.hpp
+++ b/include/seqan3/core/type_traits/all.hpp
@@ -6,21 +6,17 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides various type traits.
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
- */
-
-/*!\defgroup type_traits Type Traits
- * \brief Provides various type traits and their shortcuts.
- * \ingroup core
+ * \brief [DEPRECATED] Provides various type traits.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/utility/type_traits/all.hpp> instead.
  */
 
 #pragma once
 
-#include <seqan3/core/type_traits/pre.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/deferred_crtp_base.hpp>
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
+#include <seqan3/utility/type_traits/all.hpp>
+
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/utility/type_traits/all.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/basic.hpp b/include/seqan3/core/type_traits/basic.hpp
index b49032f620..6c75c68f77 100644
--- a/include/seqan3/core/type_traits/basic.hpp
+++ b/include/seqan3/core/type_traits/basic.hpp
@@ -6,164 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides various type traits on generic types.
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides various type traits on generic types.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/utility/type_traits/basic.hpp> instead.
  */
 
 #pragma once
 
-#include <tuple>
-#include <seqan3/std/type_traits>
-#include <type_traits>
+#include <seqan3/utility/type_traits/basic.hpp>
 
-#include <seqan3/core/platform.hpp>
-
-// ----------------------------------------------------------------------------
-// is_constexpr
-// ----------------------------------------------------------------------------
-
-/*!\brief Returns true if the expression passed to this macro can be evaluated at compile time, false otherwise.
- * \ingroup type_traits
- * \returns true or false.
- */
-#define SEQAN3_IS_CONSTEXPR(...) std::integral_constant<bool, __builtin_constant_p((__VA_ARGS__, 0))>::value
-
-namespace seqan3
-{
-
-/*!\addtogroup type_traits
- * \{
- */
-
-// ----------------------------------------------------------------------------
-// remove_cvref_t
-// ----------------------------------------------------------------------------
-
-/*!\brief Return the input type with `const`, `volatile` and references removed (type trait).
- * \tparam t The type to operate on.
- */
-template <typename t>
-using remove_cvref_t SEQAN3_DEPRECATED_310 = std::remove_cv_t<std::remove_reference_t<t>>;
-
-// ----------------------------------------------------------------------------
-// remove_rvalue_reference
-// ----------------------------------------------------------------------------
-
-/*!\brief Return the input type with `&&` removed, but lvalue references preserved.
- * \implements seqan3::transformation_trait
- * \tparam t The type to operate on.
- * \see seqan3::remove_rvalue_reference_t
- */
-template <typename t>
-struct remove_rvalue_reference
-{
-    //!\brief The return type is the input type with any `&&` stripped.
-    using type = std::conditional_t<std::is_rvalue_reference_v<t>, std::remove_reference_t<t>, t>;
-};
-
-/*!\brief Return the input type with `&&` removed, but lvalue references preserved (transformation_trait shortcut).
- * \tparam t The type to operate on.
- * \see seqan3::remove_rvalue_reference
- */
-template <typename t>
-using remove_rvalue_reference_t = typename remove_rvalue_reference<t>::type;
-
-// ----------------------------------------------------------------------------
-// is_constexpr_default_constructible
-// ----------------------------------------------------------------------------
-
-/*!\brief Whether a type std::is_default_constructible in `constexpr`-context.
- * \implements seqan3::unary_type_trait
- * \tparam t The type to operate on.
- */
-template <typename t>
-struct is_constexpr_default_constructible : std::false_type
-{};
-
-/*!\brief Whether a type std::is_default_constructible in `constexpr`-context (unary_type_trait specialisation).
- * \tparam t A type that std::is_default_constructible.
- * \see seqan3::is_constexpr_default_constructible
- */
-template <typename t>
-//!\cond
-    requires std::is_default_constructible_v<t>
-//!\endcond
-struct is_constexpr_default_constructible<t> : std::integral_constant<bool, SEQAN3_IS_CONSTEXPR(t{})>
-{};
-
-/*!\brief Whether a type std::is_default_constructible in `constexpr`-context (unary_type_trait shortcut).
- * \tparam t The type to operate on.
- * \relates seqan3::is_constexpr_default_constructible
- */
-template <typename t>
-inline constexpr bool is_constexpr_default_constructible_v = is_constexpr_default_constructible<t>::value;
-
-//!\}
-} // namespace seqan3
-
-namespace seqan3::detail
-{
-
-/*!\addtogroup type_traits
- * \{
- */
-
-// ----------------------------------------------------------------------------
-// deferred_type
-// ----------------------------------------------------------------------------
-
-/*!\brief Return the type identity; further arguments are ignored, but can make this type dependent if they are.
- * \implements seqan3::transformation_trait
- * \tparam t The type to operate on.
- * \tparam dependent_ts Any provided types are ignored.
- * \see seqan3::detail::deferred_type_t
- */
-template <typename t, typename ...dependent_ts>
-struct deferred_type
-{
-    //!\brief The type identity.
-    using type = t;
-};
-
-/*!\brief Return the type identity; further arguments are ignored, but can make this type dependent if they are
- *        (transformation_trait shortcut).
- * \tparam t The type to operate on.
- * \tparam dependent_ts Any provided types are ignored.
- * \see seqan3::detail::deferred_type
- */
-template <typename t, typename ...dependent_ts>
-using deferred_type_t = typename deferred_type<t, dependent_ts...>::type;
-
-// ----------------------------------------------------------------------------
-// ignore_t
-// ----------------------------------------------------------------------------
-
-//!\brief Return the type of std::ignore with `const`, `volatile` and references removed (type trait).
-using ignore_t = std::remove_cvref_t<decltype(std::ignore)>;
-
-/*!\brief Return whether the input type with `const`, `volatile` and references removed is std::ignore's type.
- * (type trait).
- * \tparam t The type to operate on.
- */
-template <typename t>
-constexpr bool decays_to_ignore_v = std::is_same_v<std::remove_cvref_t<t>, ignore_t>;
-
-//!\}
-
-} // namespace seqan3::detail
-
-// ----------------------------------------------------------------------------
-// SEQAN3_IS_SAME
-// ----------------------------------------------------------------------------
-
-/*!\brief A macro that behaves like std::is_same_v, except that it doesn't need to instantiate the template on GCC and
- *        Clang.
- * \ingroup type_traits
- */
-#if defined(__clang__)
-#   define SEQAN3_IS_SAME(...)              __is_same(__VA_ARGS__)
-#elif defined(__GNUC__)
-#   define SEQAN3_IS_SAME(...)              __is_same_as(__VA_ARGS__)
-#else
-#   define SEQAN3_IS_SAME(...)              std::is_same_v<__VA_ARGS__>
-#endif
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/utility/type_traits/basic.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/concept.hpp b/include/seqan3/core/type_traits/concept.hpp
index a39a4a8b8a..f2349d1ba9 100644
--- a/include/seqan3/core/type_traits/concept.hpp
+++ b/include/seqan3/core/type_traits/concept.hpp
@@ -6,39 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides the concepts seqan3::transformation_trait and seqan3::unary_type_trait.
- * \author Svenja Mehringer <svenja.mehringer AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides the concepts seqan3::transformation_trait and seqan3::unary_type_trait.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/utility/type_traits/concept.hpp> instead.
  */
 
 #pragma once
 
-#include <type_traits>
+#include <seqan3/utility/type_traits/concept.hpp>
 
-#include <seqan3/core/platform.hpp>
-
-namespace seqan3
-{
-
-/*!\interface seqan3::transformation_trait
- * \ingroup type_traits
- * \brief Concept for a transformation trait.
- *
- * An object is a transformation trait if it exposes a member type called `type`.
- */
-//!\cond
-template <typename t>
-SEQAN3_CONCEPT transformation_trait = requires { typename t::type; };
-//!\endcond
-
-/*!\interface seqan3::unary_type_trait
- * \ingroup type_traits
- * \brief Concept for a unary traits type.
- *
- * An object is a unary traits type if it is derived from std::integral_constant.
- */
-//!\cond
-template <typename t>
-SEQAN3_CONCEPT unary_type_trait = std::is_base_of_v<std::integral_constant<typename t::value_type, t::value>, t>;
-//!\endcond
-
-} // namespace seqan3
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/utility/type_traits/concept.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/deferred_crtp_base.hpp b/include/seqan3/core/type_traits/deferred_crtp_base.hpp
index cfdcb2393f..c0e720468b 100644
--- a/include/seqan3/core/type_traits/deferred_crtp_base.hpp
+++ b/include/seqan3/core/type_traits/deferred_crtp_base.hpp
@@ -6,96 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides seqan3::detail::deferred_crtp_base.
- * \author Rene Rahn <rene.rahn AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides seqan3::detail::deferred_crtp_base.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/core/detail/deferred_crtp_base.hpp> instead.
  */
 
 #pragma once
 
-#include <seqan3/core/platform.hpp>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
 
-namespace seqan3::detail
-{
-
-/*!\brief An invocable wrapper that defers the instantiation of a crtp_base class.
- * \ingroup type_traits
- * \tparam crtp_base The crtp base class to be deferred. Must be a template template parameter.
- * \tparam args_t    A type template parameter pack used to augment the `crtp_base` class.
- *
- * \details
- *
- * This transformation trait wrapper allows to defer the template instantiation of crtp-base classes. This can be useful
- * if the crtp_base class should be augmented with traits or other templates, especially when using variadic
- * crtp_bases. The help function seqan3::detail::invoke_deferred_crtp_base can be used to instantiate the
- * deferred crtp base with the respective derived type.
- *
- * ### Example
- *
- * The following snippet demonstrates the use of the deferred crtp base class instantiation.
- *
- * \include test/snippet/core/type_traits/deferred_crtp_base.cpp
- *
- * \see seqan3::detail::invoke_deferred_crtp_base
- * \see seqan3::detail::deferred_crtp_base_vargs
- */
-template <template <typename ...> typename crtp_base, typename ...args_t>
-struct deferred_crtp_base
-{
-    /*!\brief Invokes the deferred crtp_base with the corresponding derived type.
-     * \tparam derived_t The derived type to instantiate the crtp_base with.
-     */
-    template <typename derived_t>
-    using invoke = crtp_base<derived_t, args_t...>;
-};
-
-/*!\brief An invocable wrapper that defers the instantiation of a crtp_base class.
- * \ingroup type_traits
- * \tparam crtp_base The crtp base class to be deferred. Must be a template template parameter.
- * \tparam args      A non-type template parameter pack used to augment the `crtp_base` class.
- *
- * \details
- *
- * This transformation trait wrapper allows to defer the template instantiation of crtp-base classes. This can be useful
- * if the crtp_base class should be augmented with traits or other templates, especially when using variadic
- * crtp_bases. The help function seqan3::detail::invoke_deferred_crtp_base can be used to instantiate the
- * deferred crtp base with the respective derived type. This class wrapper can only be used to augment a crtp-base
- * class with non-type arguments. See seqan3::detail::deferred_crtp_base for a version that accepts type template
- * parameters.
- *
- * ### Example
- *
- * The following snippet demonstrates the use of the deferred crtp base class instantiation.
- *
- * \include test/snippet/core/type_traits/deferred_crtp_base.cpp
- *
- * \see seqan3::detail::invoke_deferred_crtp_base
- * \see seqan3::detail::deferred_crtp_base
- */
-template <template <typename, auto ...> typename crtp_base, auto ...args>
-struct deferred_crtp_base_vargs
-{
-    /*!\brief Invokes the deferred crtp_base with the corresponding derived type.
-     * \tparam derived_t The derived type to instantiate the crtp_base with.
-     */
-    template <typename derived_t>
-    using invoke = crtp_base<derived_t, args...>;
-};
-
-/*!\brief Template alias to instantiate the deferred crtp base with the derived class.
- * \ingroup type_traits
- * \tparam deferred_crtp_base_t The deferred crtp base class.
- * \tparam derived_t            The derived type to instantiate the crtp base class with.
- *
- * \details
- *
- * Effectively declares the type resulting from `deferred_crtp_base_t::template invoke<derived_t>`.
- *
- * \see seqan3::detail::deferred_crtp_base
- */
-template <typename deferred_crtp_base_t, typename derived_t>
-//!\cond
-    requires requires { typename deferred_crtp_base_t::template invoke<derived_t>; }
-//!\endcond
-using invoke_deferred_crtp_base = typename deferred_crtp_base_t::template invoke<derived_t>;
-
-} // namespace seqan3::detail
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/core/detail/deferred_crtp_base.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/function.hpp b/include/seqan3/core/type_traits/function.hpp
index 0706b05e92..db42a5c62c 100644
--- a/include/seqan3/core/type_traits/function.hpp
+++ b/include/seqan3/core/type_traits/function.hpp
@@ -6,91 +6,15 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides various type traits for use on functions.
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides various type traits for use on functions.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/utility/type_traits/function_traits.hpp>
+ *             or <seqan3/utility/detail/multi_invocable.hpp> instead.
  */
 
 #pragma once
 
-#include <functional>
+#include <seqan3/utility/detail/multi_invocable.hpp>
+#include <seqan3/utility/type_traits/function_traits.hpp>
 
-#include <seqan3/utility/type_pack/traits.hpp>
-
-namespace seqan3
-{
-// ----------------------------------------------------------------------------
-// function_traits
-// ----------------------------------------------------------------------------
-
-//!\cond
-template <typename function_t>
-struct function_traits;
-//!\endcond
-
-/*!\brief A traits class to provide a uniform interface to the properties of a function type.
- * \ingroup type_traits
- * \tparam return_t The return type of the function.
- * \tparam args_t A template parameter pack over the argument types of the function.
- *
- * \details
- *
- * seqan3::function_traits is the type trait class that provides a uniform interface to the properties of
- * a std::function type, a lambda type, a function type or a function pointer type.
- * This makes it possible to access the return type and the argument types of the stored target function.
- * The function types must be complete, i.e. all argument types and the return type must be known, otherwise
- * this traits class is incomplete.
- *
- * ### Example
- *
- * \include snippet/core/type_traits/function_traits.cpp
- */
-template <typename return_t, typename ...args_t>
-struct function_traits<std::function<return_t(args_t...)>>
-{
-    //!\brief The number of arguments passed to the std::function target.
-    static constexpr size_t argument_count = sizeof...(args_t);
-
-    //!\brief The return type of the function target.
-    using result_type = return_t;
-
-    /*!\brief The argument type at the given `index`.
-     * \tparam index The position of the argument to get the type for; must be smaller than `argument_count`.
-     */
-    template <size_t index>
-    //!\cond
-        requires (index < argument_count)
-    //!\endcond
-    using argument_type_at = pack_traits::at<index, args_t...>;
-};
-
-//!\cond
-// Overload for all function types.
-template <typename function_t>
-    requires requires (function_t fn) { {std::function{fn}}; }
-struct function_traits<function_t> : function_traits<decltype(std::function{std::declval<function_t>()})>
-{};
-//!\endcond
-} // namespace seqan3
-
-namespace seqan3::detail
-{
-// ----------------------------------------------------------------------------
-// multi_invocable
-// ----------------------------------------------------------------------------
-
-/*!\brief A type that can conveniently inherit multiple invocables and acts as a union over them.
- * \tparam invocable_ts The types to inherit from.
- * \ingroup type_traits
- */
-template <typename ...invocable_ts>
-struct multi_invocable : invocable_ts...
-{
-    //!\brief Inherit the function call operators.
-    using invocable_ts::operator()...;
-};
-
-//!\brief Deduction guides for seqan3::detail::multi_invocable.
-template <typename ...invocable_ts>
-multi_invocable(invocable_ts...) -> multi_invocable<invocable_ts...>;
-
-} // namespace seqan3::detail
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/utility/type_traits/function_traits.hpp> or <seqan3/utility/detail/multi_invocable.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/iterator.hpp b/include/seqan3/core/type_traits/iterator.hpp
index a15e6f92c6..5537a41c71 100644
--- a/include/seqan3/core/type_traits/iterator.hpp
+++ b/include/seqan3/core/type_traits/iterator.hpp
@@ -6,268 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides various transformation traits for use on iterators.
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides various transformation traits for use on iterators.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/core/detail/iterator_traits.hpp> instead.
  */
 
 #pragma once
 
-#include <iterator>
-#include <type_traits>
+#include <seqan3/core/detail/iterator_traits.hpp>
 
-#include <seqan3/core/platform.hpp>
-#include <seqan3/core/type_traits/pre.hpp>
-#include <seqan3/std/iterator>
-
-namespace seqan3
-{
-
-/*!\addtogroup type_traits
- * \{
- */
-
-// ----------------------------------------------------------------------------
-// value_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `value_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type you wish to query; must model std::input_iterator.
- * \deprecated This is deprecated use std::iter_value_t.
- */
-template <std::input_iterator it_t>
-struct value_type<it_t>
-{
-    //!\brief Return the member type as return type.
-    using type = std::iter_value_t<it_t>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `reference` type of another type.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type you wish to query; must model std::input_iterator.
- * \deprecated This is deprecated use std::iter_reference_t.
- */
-template <std::input_iterator it_t>
-struct reference<it_t>
-{
-    //!\brief Return the member type as return type.
-    using type = std::iter_reference_t<it_t>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// rvalue_reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `rvalue_reference` type of another type.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type you wish to query; must model std::input_iterator.
- * \deprecated This is deprecated use std::iter_rvalue_reference_t.
- */
-template <std::input_iterator it_t>
-struct rvalue_reference<it_t>
-{
-    //!\brief Return the member type as return type.
-    using type = std::iter_rvalue_reference_t<it_t>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// const_reference
-// ----------------------------------------------------------------------------
-
-// only defined for ranges
-
-// ----------------------------------------------------------------------------
-// difference_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `difference_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type you wish to query; must model std::weakly_incrementable.
- * \deprecated This is deprecated use std::iter_difference_t.
- */
-template <std::weakly_incrementable it_t>
-struct difference_type<it_t>
-{
-    //!\brief Return the member type as return type.
-    using type = std::iter_difference_t<it_t>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// size_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `size_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type you wish to query; must model std::weakly_incrementable.
- * \deprecated This is deprecated. There is no alternative! Unlike std::ranges::range_size_t, the Standard has no
- *            std::iter_size_t. We decided that it does not make sense to define it on the difference type of the
- *            iterator.
- */
-template <std::weakly_incrementable it_t>
-struct size_type<it_t>
-{
-    //!\brief Return the member type as return type.
-    using type = std::make_unsigned_t<std::iter_difference_t<it_t>>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// see specialisation for ranges in core/type_traits/range.hpp
-//!\}
-
-} // namespace seqan3
-
-namespace seqan3::detail
-{
-#if SEQAN3_WORKAROUND_GCC_96070
-//!\cond
-template <typename it_t>
-struct iterator_category_tag
-{
-    using type = void;
-};
-
-template <typename it_t>
-    requires requires { typename std::iterator_traits<it_t>::iterator_category; }
-struct iterator_category_tag<it_t>
-{
-    using type = typename std::iterator_traits<it_t>::iterator_category;
-};
-//!\endcond
-/*!\brief Exposes the
- * [iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_tags) from the modelled concept.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type to operate on.
- *
- * \attention
- * If [std::iterator_traits<it_t>::iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_traits)
- * is defined for a type `it_t`, this transformation trait acts as an alias for it, if not it is `void`.
- */
-template <typename it_t>
-using iterator_category_tag_t = typename iterator_category_tag<it_t>::type;
-#else // ^^^ workaround / no workaround vvv
-// TODO: Change the description / the definition of iterator_category_tag_t depending on how the standard resolves this
-// https://github.com/seqan/product_backlog/issues/151
-
-/*!\brief Exposes the
- * [iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_tags) from the modelled concept.
- * \tparam it_t The type to operate on.
- *
- * \attention
- * If [std::iterator_traits<it_t>::iterator_category](https://en.cppreference.com/w/cpp/iterator/iterator_traits)
- * is defined for a type `it_t`, this transformation trait acts as an alias for it.
- *
- * If not, this means that `it_t` is no "legacy" iterator and this transformation trait will give a substitution error.
- */
-template <typename it_t>
-//!\cond
-    requires requires { typename std::iterator_traits<it_t>::iterator_category; }
-//!\endcond
-using iterator_category_tag_t = typename std::iterator_traits<it_t>::iterator_category;
-#endif // SEQAN3_WORKAROUND_GCC_96070
-
-/*!\brief Exposes the
- * [iterator_concept](https://en.cppreference.com/w/cpp/iterator/iterator_tags) from the modelled concept.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type to operate on.
- */
-template <typename it_t>
-//!\cond
-    requires std::input_or_output_iterator<it_t>
-//!\endcond
-using iterator_concept_tag_t =
-    std::conditional_t<
-        std::contiguous_iterator<it_t>,
-        std::contiguous_iterator_tag,
-        std::conditional_t<
-            std::random_access_iterator<it_t>,
-            std::random_access_iterator_tag,
-            std::conditional_t<
-                std::bidirectional_iterator<it_t>,
-                std::bidirectional_iterator_tag,
-                std::conditional_t<
-                    std::forward_iterator<it_t>,
-                    std::forward_iterator_tag,
-                    std::conditional_t<
-                        std::input_iterator<it_t>,
-                        std::input_iterator_tag,
-                        std::output_iterator_tag>>>>>;
-
-} // namespace seqan3::detail
-
-namespace seqan3::detail
-{
-// ----------------------------------------------------------------------------
-// iter_pointer
-// ----------------------------------------------------------------------------
-
-/*!\brief This is like std::iter_value_t, but for the pointer type.
- * \implements seqan3::transformation_trait
- * \tparam it_t The type to operate on.
- * \see seqan3::detail::iter_pointer_t
- *
- * \attention
- * C++20 does not provide a `std::iter_pointer_t`, because the new C++20 iterators do not need to provide a pointer
- * type.
- */
-template <typename it_t>
-struct iter_pointer
-{
-    //!\brief The pointer type of std::iterator_traits or void.
-    using type = void;
-};
-
-//!\cond
-template <typename it_t>
-    requires requires { typename std::iterator_traits<it_t>::pointer; }
-struct iter_pointer<it_t>
-{
-    //!\brief This is defined for every legacy input-iterator.
-    //!\sa https://en.cppreference.com/w/cpp/iterator/iterator_traits
-    using type = typename std::iterator_traits<it_t>::pointer;
-};
-//!\endcond
-
-/*!\brief Return the `pointer` type of the input type (transformation_trait shortcut).
- * \tparam it_t The type to operate on.
- * \see seqan3::detail::iter_pointer
- */
-template <typename it_t>
-using iter_pointer_t = typename iter_pointer<it_t>::type;
-
-} // namespace seqan3::detail
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/core/detail/iterator_traits.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/lazy.hpp b/include/seqan3/core/type_traits/lazy.hpp
index 85faba9ed2..7ed2a7ed98 100644
--- a/include/seqan3/core/type_traits/lazy.hpp
+++ b/include/seqan3/core/type_traits/lazy.hpp
@@ -6,194 +6,15 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides lazy template instantiation traits.
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides lazy template instantiation traits.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/utility/type_traits/lazy_conditional.hpp>
+ *             or <seqan3/core/detail/is_class_template_declarable.hpp> instead.
  */
 
 #pragma once
 
-#include <seqan3/std/type_traits>
+#include <seqan3/core/detail/is_class_template_declarable.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
-#include <seqan3/core/platform.hpp>
-
-namespace seqan3::detail
-{
-
-/*!\addtogroup type_traits
- * \{
- */
-
-// ----------------------------------------------------------------------------
-// lazy
-// ----------------------------------------------------------------------------
-
-/*!\brief An empty type whose only purpose is to hold an uninstantiated template plus its arguments.
- * \tparam template_t The uninstantiated template.
- * \tparam spec_t     The arguments to template_t.
- */
-template <template <typename ...> typename template_t, typename ...spec_t>
-struct lazy
-{};
-
-// ----------------------------------------------------------------------------
-// instantiate
-// ----------------------------------------------------------------------------
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types. Base template is the identity transformation.
- * \tparam t The type to operate on.
- * \implements seqan3::transformation_trait
- */
-template <typename t>
-struct instantiate : std::type_identity<t>
-{};
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types.
- * \tparam template_t The uninstantiated template.
- * \tparam spec_t     The arguments to template_t.
- * \implements seqan3::transformation_trait
- */
-template <template <typename ...> typename template_t, typename ...spec_t>
-struct instantiate<lazy<template_t, spec_t...>>
-{
-    //!\brief Return type of the trait [instantiates the template arguments].
-    using type = template_t<spec_t...>;
-};
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types. Transformation trait shortcut.
- * \tparam t The type to operate on.
- * \relates seqan3::detail::instantiate
- */
-template <typename t>
-//!\cond
-    requires requires { typename instantiate<t>::type; }
-//!\endcond
-using instantiate_t = typename instantiate<t>::type;
-
-// ----------------------------------------------------------------------------
-// instantiate_if
-// ----------------------------------------------------------------------------
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types given a boolean condition.
- *        Base template is std::false_type.
- * \tparam t The type to operate on.
- * \implements seqan3::transformation_trait
- */
-template <typename t, bool condition>
-struct instantiate_if : std::false_type
-{};
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types given a boolean condition.
- *        If condition is true and parameter is not lazy, the type identity.
- * \tparam t The type to operate on.
- * \implements seqan3::transformation_trait
- */
-template <typename t>
-struct instantiate_if<t, true> : std::type_identity<t>
-{};
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types given a boolean condition.
- *        If condition is true and parameter is lazy, the instantiated type.
- * \tparam template_t The uninstantiated template.
- * \tparam spec_t     The arguments to template_t.
- * \implements seqan3::transformation_trait
- */
-template <template <typename ...> typename template_t, typename ...spec_t>
-struct instantiate_if<lazy<template_t, spec_t...>, true>
-{
-    //!\brief Return type of the trait [instantiates the template arguments].
-    using type = template_t<spec_t...>;
-};
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types, conditionally. Transformation trait shortcut.
- * \tparam t The type to operate on.
- * \relates seqan3::detail::instantiate_if
- */
-template <typename t, bool condition>
-//!\cond
-    requires requires { typename instantiate_if<t, condition>::type; }
-//!\endcond
-using instantiate_if_t = typename instantiate_if<t, condition>::type;
-
-/*!\brief A transformation trait that instantiates seqan3::lazy types, conditionally. Type trait shortcut.
- * \tparam t The type to operate on.
- * \relates seqan3::detail::instantiate_if
- */
-template <typename t, bool condition>
-//!\cond
-    requires requires { instantiate_if_t<t, condition>::value; }
-//!\endcond
-inline constexpr auto instantiate_if_v = instantiate_if_t<t, condition>::value;
-
-// ----------------------------------------------------------------------------
-// lazy_conditional
-// ----------------------------------------------------------------------------
-
-/*!\brief Behaves like std::conditional, but instantiates types wrapped in seqan3::lazy.
- * \tparam decision   Whether to resolve to the first type or the second.
- * \tparam on_true_t  The return type in case `decision` is true.
- * \tparam on_false_t The return type in case `decision` is false.
- * \implements seqan3::transformation_trait
- *
- * \details
- *
- * ### Example
- *
- * \include test/snippet/core/type_traits/lazy.cpp
- */
-template <bool decision, typename on_true_t, typename on_false_t>
-struct lazy_conditional : instantiate<std::conditional_t<decision, on_true_t, on_false_t>>
-{};
-
-/*!\brief Behaves like std::conditional_t, but instantiates types wrapped in seqan3::lazy. Transformation trait shortcut.
- * \tparam decision   Whether to resolve to the first type or the second.
- * \tparam on_true_t  The return type in case `decision` is true.
- * \tparam on_false_t The return type in case `decision` is false.
- * \relates seqan3::detail::lazy_conditional
- */
-template <bool decision, typename on_true_t, typename on_false_t>
-//!\cond
-    requires requires { typename instantiate_t<std::conditional_t<decision, on_true_t, on_false_t>>; }
-//!\endcond
-using lazy_conditional_t = instantiate_t<std::conditional_t<decision, on_true_t, on_false_t>>;
-
-/*!\brief An unary type trait that tests whether a template class can be declared with the given template type
- *        parameters.
- * \implements seqan3::unary_type_trait
- * \tparam query_t The type of the template class to test.
- * \tparam args_t  The template parameter pack to instantiate the template class with.
- *
- * \details
- *
- * Note, this unary type trait can be used in a seqan3::detail::lazy_conditional expression to check if instantiating
- * a template class with specific template arguments would result in a valid template declaration. Thus, the template
- * parameters of the checked class must be constrained accordingly. It is, however, not possible to test if the
- * the resulting type is incomplete or not, such that it can not be tested if an instance of the class template with
- * the given template arguments can be actually created.
- *
- * ### Example
- *
- * \include test/snippet/core/type_traits/is_class_template_declarable_with.cpp
- */
-template <template <typename ...> typename query_t, typename ...args_t>
-struct is_class_template_declarable_with :
-//!\cond
-    public std::false_type
-//!\endcond
-{};
-
-//!\cond
-template <template <typename ...> typename query_t, typename ...args_t>
-    requires requires { typename std::type_identity<query_t<args_t...>>::type; }
-struct is_class_template_declarable_with<query_t, args_t...> : public std::true_type
-{};
-//!\endcond
-
-/*!\brief Helper variable template for seqan3::detail::is_class_template_declarable_with.
- * \tparam query_t The type of the template class to test.
- * \tparam args_t  The template parameter pack to instantiate the template class with.
- * \relates seqan3::detail::is_class_template_declarable_with
- */
-template <template <typename ...> typename query_t, typename ...args_t>
-inline constexpr bool is_class_template_declarable_with_v = is_class_template_declarable_with<query_t, args_t...>::value;
-//!\}
-} // namespace seqan3::detail
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/utility/type_traits/lazy_conditional.hpp> or <seqan3/core/detail/is_class_template_declarable.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/pack.hpp b/include/seqan3/core/type_traits/pack.hpp
index 4bc1cd39ea..60d3c89894 100644
--- a/include/seqan3/core/type_traits/pack.hpp
+++ b/include/seqan3/core/type_traits/pack.hpp
@@ -7,14 +7,17 @@
 
 /*!\file
  * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
- * \brief Provides unary type traits on a set of types, usually provided as template argument pack.
+ * \brief [DEPRECATED] Provides unary type traits on a set of types, usually provided as template argument pack.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please use seqan3::pack_traits::contains in <seqan3/core/type_list/traits.hpp> instead.
  */
 
 #pragma once
 
-#include <type_traits>
-
 #include <seqan3/core/platform.hpp>
+#include <seqan3/core/type_list/traits.hpp>
+
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please use seqan3::pack_traits::contains in <seqan3/core/type_list/traits.hpp> instead.")
 
 namespace seqan3::detail
 {
@@ -22,23 +25,22 @@ namespace seqan3::detail
 //!\addtogroup type_traits
 //!\{
 
-//!\brief Indicates whether the first template argument is contained in the remaining.
-//!\implements seqan3::unary_type_trait
-template <typename target_t, typename ...pack>
-struct type_in_pack : std::false_type {};
-
-//!\cond
+/*!\brief [DEPRECATED] Indicates whether the first template argument is contained in the remaining.
+ * \implements seqan3::unary_type_trait
+ * \deprecated This struct is deprecated and will be removed in SeqAn-3.1.
+ *             Please use seqan3::pack_traits::contains instead.
+ */
 template <typename target_t, typename ...pack>
-struct type_in_pack<target_t, target_t, pack...> : std::true_type {};
-
-template <typename target_t, typename pack1, typename ...pack>
-struct type_in_pack<target_t, pack1, pack...> : type_in_pack<target_t, pack...> {};
-//!\endcond
+struct SEQAN3_DEPRECATED_310 type_in_pack : std::conditional_t<seqan3::pack_traits::contains<target_t, pack...>,
+                                                               std::true_type,
+                                                               std::false_type> {};
 
-//!\brief Shortcut for seqan3::detail::type_in_pack (unary_type_trait shortcut).
-//!\relates seqan3::detail::type_in_pack
+/*!\brief [DEPRECATED] Shortcut for seqan3::detail::type_in_pack (unary_type_trait shortcut).
+ * \deprecated This variable is deprecated and will be removed in SeqAn-3.1.
+ *             Please use seqan3::pack_traits::contains instead.
+ */
 template <typename target_t, typename ...pack>
-inline bool constexpr type_in_pack_v = type_in_pack<target_t, pack...>::value;
+SEQAN3_DEPRECATED_310 inline bool constexpr type_in_pack_v = seqan3::pack_traits::contains<target_t, pack...>;
 
 //!\}
 
diff --git a/include/seqan3/core/type_traits/pre.hpp b/include/seqan3/core/type_traits/pre.hpp
index 7b18cd93e8..50b90bd548 100644
--- a/include/seqan3/core/type_traits/pre.hpp
+++ b/include/seqan3/core/type_traits/pre.hpp
@@ -6,318 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides various transformation trait base templates and shortcuts.
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides various transformation trait base templates and shortcuts.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/utility/type_traits/pre.hpp> instead.
  */
 
 #pragma once
 
-#include <seqan3/core/platform.hpp>
+#include <seqan3/utility/type_traits/pre.hpp>
 
-namespace seqan3
-{
-
-/*!\addtogroup type_traits
- * \{
- */
-
-// ----------------------------------------------------------------------------
-// value_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-//!\brief This is helper structure to deprecate seqan3::value_type and will be removed before SeqAn 3.1.
-template <typename t>
-struct value_type;
-
-//!\brief This is helper structure to deprecate seqan3::value_type_t and will be removed before SeqAn 3.1.
-template <typename t>
-using value_type_t = typename value_type<t>::type;
-} // namespace seqan3::detail
-#endif
-
-/*!\brief Exposes the `value_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query.
- * \see seqan3::value_type_t
- *
- * \details
- *
- * This is a pure declaration, you need to create a *definition* for concrete types
- * or specialized or constrained templates.
- *
- * There is a shortcut for this transformation trait: seqan3::value_type_t
- *
- * \deprecated If `t` models std::ranges::range use std::ranges::range_value_t instead or
- *             if `t` models std::input_iterator use std::iter_value_t instead.
- */
-template <typename t>
-struct SEQAN3_DEPRECATED_310 value_type : detail::value_type<t>
-{};
-
-/*!\brief Shortcut for seqan3::value_type (transformation_trait shortcut).
- * \tparam t The type you wish to query.
- * \see seqan3::value_type
- * \deprecated If `t` models std::ranges::range use std::ranges::range_value_t instead or
- *             if `t` models std::input_iterator use std::iter_value_t instead.
- */
-template <typename t>
-using value_type_t SEQAN3_DEPRECATED_310 = typename detail::value_type_t<t>;
-
-// see specialisation for iterators in core/type_traits/iterator.hpp
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-//!\brief This is helper structure to deprecate seqan3::reference and will be removed before SeqAn 3.1.
-template <typename t>
-struct reference;
-
-//!\brief This is helper structure to deprecate seqan3::reference_t and will be removed before SeqAn 3.1.
-template <typename t>
-using reference_t = typename reference<t>::type;
-} // namespace seqan3::detail
-#endif
-
-/*!\brief Exposes the `reference` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query.
- * \see seqan3::reference_t
- *
- * \details
- *
- * This is a pure declaration, you need to create a *definition* for concrete types
- * or specialized or constrained templates.
- *
- * There is a shortcut for this transformation trait: seqan3::reference_t
- *
- * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t instead or
- *             if `t` models std::input_iterator use std::iter_reference_t instead.
- */
-template <typename t>
-struct SEQAN3_DEPRECATED_310 reference : detail::reference<t>
-{};
-
-/*!\brief Shortcut for seqan3::reference (transformation_trait shortcut).
- * \tparam t The type you wish to query.
- * \see seqan3::reference
- * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t instead or
- *             if `t` models std::input_iterator use std::iter_reference_t instead.
- */
-template <typename t>
-using reference_t SEQAN3_DEPRECATED_310 = typename detail::reference_t<t>;
-
-// see specialisation for iterators in core/type_traits/iterator.hpp
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// rvalue_reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-//!\brief This is helper structure to deprecate seqan3::rvalue_reference and will be removed before SeqAn 3.1.
-template <typename t>
-struct rvalue_reference;
-
-//!\brief This is helper structure to deprecate seqan3::rvalue_reference_t and will be removed before SeqAn 3.1.
-template <typename t>
-using rvalue_reference_t = typename rvalue_reference<t>::type;
-} // namespace seqan3::detail
-#endif
-
-/*!\brief Exposes the `rvalue_reference` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query.
- * \see seqan3::rvalue_reference_t
- *
- * \details
- *
- * This is a pure declaration, you need to create a *definition* for concrete types
- * or specialized or constrained templates.
- *
- * There is a shortcut for this transformation trait: seqan3::rvalue_reference_t
- *
- * \deprecated If `t` models std::ranges::range use std::ranges::range_rvalue_reference_t instead or
- *             if `t` models std::input_iterator use std::iter_rvalue_reference_t instead.
- */
-template <typename t>
-struct SEQAN3_DEPRECATED_310 rvalue_reference : detail::rvalue_reference<t>
-{};
-
-/*!\brief Shortcut for seqan3::rvalue_reference (transformation_trait shortcut).
- * \tparam t The type you wish to query.
- * \see seqan3::rvalue_reference
- * \deprecated If `t` models std::ranges::range use std::ranges::range_rvalue_reference_t instead or
- *             if `t` models std::input_iterator use std::iter_rvalue_reference_t instead.
- */
-template <typename t>
-using rvalue_reference_t SEQAN3_DEPRECATED_310 = typename detail::rvalue_reference_t<t>;
-
-// see specialisation for iterators in core/type_traits/iterator.hpp
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// const_reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-//!\brief This is helper structure to deprecate seqan3::const_reference and will be removed before SeqAn 3.1.
-template <typename t>
-struct const_reference;
-
-//!\brief This is helper structure to deprecate seqan3::const_reference_t and will be removed before SeqAn 3.1.
-template <typename t>
-using const_reference_t = typename const_reference<t>::type;
-} // namespace seqan3::detail
-#endif
-
-/*!\brief Exposes the `const_reference` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query.
- * \see seqan3::const_reference_t
- *
- * \details
- *
- * This is a pure declaration, you need to create a *definition* for concrete types
- * or specialized or constrained templates.
- *
- * There is a shortcut for this transformation trait: seqan3::const_reference_t
- *
- * \attention This transformation trait is not overloaded for iterators by default, but it is for ranges.
- *
- * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t<t const> instead or
- *             if `t` models std::input_iterator use std::iter_reference_t<t const> instead.
- */
-template <typename t>
-struct SEQAN3_DEPRECATED_310 const_reference : detail::const_reference<t>
-{};
-
-
-/*!\brief Shortcut for seqan3::const_reference (transformation_trait shortcut).
- * \tparam t The type you wish to query.
- * \see seqan3::const_reference
- * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t<t const> instead or
- *             if `t` models std::input_iterator use std::iter_reference_t<t const> instead.
- */
-template <typename t>
-using const_reference_t SEQAN3_DEPRECATED_310 = typename detail::const_reference_t<t>;
-
-
-// no specialisation for iterators
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// difference_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-//!\brief This is helper structure to deprecate seqan3::difference_type and will be removed before SeqAn 3.1.
-template <typename t>
-struct difference_type;
-
-//!\brief This is helper structure to deprecate seqan3::difference_type_t and will be removed before SeqAn 3.1.
-template <typename t>
-using difference_type_t = typename difference_type<t>::type;
-} // namespace seqan3::detail
-#endif
-
-/*!\brief Exposes the `difference_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query.
- * \see seqan3::difference_type_t
- *
- * \details
- *
- * This is a pure declaration, you need to create a *definition* for concrete types
- * or specialized or constrained templates.
- *
- * There is a shortcut for this transformation trait: seqan3::difference_type_t
- *
- * \deprecated If `t` models std::ranges::range use std::ranges::range_difference_t instead or
- *             if `t` models std::input_iterator use std::iter_difference_t instead.
- */
-template <typename t>
-struct SEQAN3_DEPRECATED_310 difference_type : detail::difference_type<t>
-{};
-
-
-/*!\brief Shortcut for seqan3::difference_type (transformation_trait shortcut).
- * \tparam t The type you wish to query.
- * \see seqan3::difference_type
- * \deprecated If `t` models std::ranges::range use std::ranges::range_difference_t instead or
- *             if `t` models std::input_iterator use std::iter_difference_t instead.
- */
-template <typename t>
-using difference_type_t SEQAN3_DEPRECATED_310 = typename detail::difference_type_t<t>;
-
-
-// see specialisation for iterators in core/type_traits/iterator.hpp
-// see specialisation for ranges in core/type_traits/range.hpp
-
-// ----------------------------------------------------------------------------
-// size_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-//!\brief This is helper structure to deprecate seqan3::size_type and will be removed before SeqAn 3.1.
-template <typename t>
-struct size_type;
-
-//!\brief This is helper structure to deprecate seqan3::size_type_t and will be removed before SeqAn 3.1.
-template <typename t>
-using size_type_t = typename size_type<t>::type;
-} // namespace seqan3::detail
-#endif
-
-/*!\brief Exposes the `size_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query.
- * \see seqan3::size_type_t
- *
- * \details
- *
- * This is a pure declaration, you need to create a *definition* for concrete types
- * or specialized or constrained templates.
- *
- * There is a shortcut for this transformation trait: seqan3::size_type_t
- *
- * \deprecated If `t` models std::ranges::range use std::ranges::range_size_t instead.
- *             If `t` models std::input_iterator there is no alternative. Unlike std::ranges::range_size_t, the Standard
- *             has no std::iter_size_t.
- *
- */
-template <typename t>
-struct SEQAN3_DEPRECATED_310 size_type : detail::size_type<t>
-{};
-
-/*!\brief Shortcut for seqan3::size_type (transformation_trait shortcut).
- * \tparam t The type you wish to query.
- * \see seqan3::size_type
- * \deprecated If `t` models std::ranges::range use std::ranges::size_type_t instead.
- *             If `t` models std::input_iterator there is no alternative. Unlike std::ranges::range_size_t, the Standard
- *             has no std::iter_size_t.
- */
-template <typename t>
-using size_type_t SEQAN3_DEPRECATED_310 = typename detail::size_type_t<t>;
-
-// see specialisation for iterators in core/type_traits/iterator.hpp
-// see specialisation for ranges in core/type_traits/range.hpp
-
-//!\}
-
-} // namespace seqan3
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/utility/type_traits/pre.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/range.hpp b/include/seqan3/core/type_traits/range.hpp
index ecf7b5a792..b2bdd0dc43 100644
--- a/include/seqan3/core/type_traits/range.hpp
+++ b/include/seqan3/core/type_traits/range.hpp
@@ -6,292 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides various transformation traits used by the range module.
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ * \brief [DEPRECATED] Provides various transformation traits used by the range module.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/core/range/type_traits.hpp> instead.
  */
 
 #pragma once
 
-#include <type_traits>
+#include <seqan3/core/range/type_traits.hpp>
 
-#include <seqan3/core/platform.hpp>
-#include <seqan3/core/type_traits/pre.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/std/ranges>
-#include <seqan3/std/iterator>
-
-// TODO(h-2): add innermost_reference instead of or addition to range_innermost_value?
-
-//NOTE(h-2): for the range overloads we explicitly forbid that the type is iteratoer
-// because some types are actually both (e.g. std::directory_iterator)
-
-namespace seqan3::detail
-{
-
-//!\cond
-template <typename t>
-SEQAN3_CONCEPT has_range_value_type = requires { typename std::ranges::range_value_t<std::remove_cvref_t<t>>; };
-//!\endcond
-
-//!\brief Makes range_t const if const_range is true; otherwise keeps range_t as is.
-//!\ingroup type_traits
-template <bool const_range, typename range_t>
-using maybe_const_range_t = std::conditional_t<const_range, range_t const, range_t>;
-
-//!\brief Returns the const iterator of range_t if const_range is true; otherwise the non-const iterator.
-//!\ingroup type_traits
-template <bool const_range, typename range_t>
-using maybe_const_iterator_t = std::ranges::iterator_t<maybe_const_range_t<const_range, range_t>>;
-
-//!\brief Returns the const sentinel of range_t if const_range is true; otherwise the non-const sentinel.
-//!\ingroup type_traits
-template <bool const_v, typename range_t>
-using maybe_const_sentinel_t = std::ranges::sentinel_t<maybe_const_range_t<const_v, range_t>>;
-} // namespace seqan3::detail
-
-namespace seqan3
-{
-
-/*!\addtogroup type_traits
- * \{
- */
-
-// ----------------------------------------------------------------------------
-// value_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `value_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query; must model std::ranges::input_range.
- * \deprecated This is deprecated use std::ranges::range_value_t.
- */
-template <std::ranges::input_range rng_t>
-//!\cond
-    requires (!std::input_or_output_iterator<rng_t>)
-//!\endcond
-struct value_type<rng_t>
-{
-    //!\brief Return the value_type member definition from the queried type's iterator.
-    using type = value_type_t<std::ranges::iterator_t<rng_t>>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// ----------------------------------------------------------------------------
-// reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `reference` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query; must model std::ranges::input_range.
- * \deprecated This is deprecated use std::ranges::range_reference_t.
- */
-template <std::ranges::input_range rng_t>
-//!\cond
-    requires (!std::input_or_output_iterator<rng_t>)
-//!\endcond
-struct reference<rng_t>
-{
-    //!\brief Return the reference member definition from the queried type's iterator.
-    using type = reference_t<std::ranges::iterator_t<rng_t>>;
-};
- } // namespace seqan3::detail
- #endif // SEQAN3_DEPRECATED_310
-
-// ----------------------------------------------------------------------------
-// rvalue_reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `rvalue_reference` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query; must model std::ranges::input_range.
- * \deprecated This is deprecated use std::ranges::range_rvalue_reference_t.
- */
-template <std::ranges::input_range rng_t>
-//!\cond
-    requires (!std::input_or_output_iterator<rng_t>)
-//!\endcond
-struct rvalue_reference<rng_t>
-{
-    //!\brief Return the rvalue_reference member definition from the queried type's iterator.
-    using type = rvalue_reference_t<std::ranges::iterator_t<rng_t>>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// ----------------------------------------------------------------------------
-// const_reference
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `const_reference` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query; must model std::ranges::input_range.
- * \deprecated This is deprecated use std::ranges::range_reference_t<rng_t const>.
- */
-template <std::ranges::input_range rng_t>
-//!\cond
-    requires (!std::input_or_output_iterator<rng_t>)
-//!\endcond
-struct const_reference<rng_t>
-{
-    //!\brief Resolves to the reference type of the `const_iterator` of t (not the `const iterator`!).
-    using type = std::iter_reference_t<std::ranges::iterator_t<rng_t const>>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// ----------------------------------------------------------------------------
-// difference_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `difference_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query; must model std::ranges::input_range.
- * \deprecated This is deprecated use std::ranges::range_difference_t.
- */
-template <std::ranges::range rng_t>
-//!\cond
-    requires (!std::input_or_output_iterator<rng_t>)
-//!\endcond
-struct difference_type<rng_t>
-{
-    //!\brief Return the difference_type member definition from the queried type's iterator.
-    using type = difference_type_t<std::ranges::iterator_t<rng_t>>;
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// ----------------------------------------------------------------------------
-// size_type
-// ----------------------------------------------------------------------------
-
-#ifdef SEQAN3_DEPRECATED_310
-namespace detail
-{
-/*!\brief Exposes the `size_type` of another type.
- * \implements seqan3::transformation_trait
- * \tparam t The type you wish to query; must model std::ranges::sized_range.
- * \deprecated This is deprecated use std::ranges::range_size_t.
- */
-template <std::ranges::sized_range rng_t>
-//!\cond
-    requires (!std::input_or_output_iterator<rng_t>)
-//!\endcond
-struct size_type<rng_t>
-{
-    //!\brief Return the size_type as returned by the size function.
-    using type = decltype(std::ranges::size(std::declval<rng_t &>()));
-};
-} // namespace seqan3::detail
-#endif // SEQAN3_DEPRECATED_310
-
-// ----------------------------------------------------------------------------
-// range_innermost_value
-// ----------------------------------------------------------------------------
-
-//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
-
-/*!\brief Recursively determines the `value_type` on containers and/or iterators.
- * \implements seqan3::transformation_trait
- * \tparam t The type to recurse on; must have `std::ranges::value_type_t<rng_t>`.
- *
- * \details
- *
- * Attention, this transformation trait implicitly removes cv-qualifiers on all value_types except the one returned.
- */
-template <typename t>
-//!\cond
-    requires detail::has_range_value_type<t>
-//!\endcond
-struct range_innermost_value
-{
-    //!\brief The return type (recursion not shown).
-    using type = std::ranges::range_value_t<std::remove_cvref_t<t>>;
-};
-
-//!\cond
-template <typename t>
-    requires detail::has_range_value_type<t> && detail::has_range_value_type<std::ranges::range_value_t<std::remove_cvref_t<t>>>
-struct range_innermost_value<t>
-{
-    using type = typename range_innermost_value<std::ranges::range_value_t<std::remove_cvref_t<t>>>::type;
-};
-//!\endcond
-
-//!\brief Shortcut for seqan3::range_innermost_value (transformation_trait shortcut).
-//!\see seqan3::range_innermost_value
-template <typename t>
-using range_innermost_value_t = typename range_innermost_value<t>::type;
-
-// ----------------------------------------------------------------------------
-// range_dimension_v
-// ----------------------------------------------------------------------------
-
-//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
-
-/*!\brief Returns the number of times you can call `seqan3::value_type_t` recursively on t (type trait).
- * \tparam t The type to be queried; must resolve `seqan3::value_type_t` at least once.
- *
- * \details
- *
- * Attention, this type trait implicitly removes cv-qualifiers and reference from the types it recurses on and
- * returns.
- */
-template <typename t>
-//!\cond
-    requires detail::has_range_value_type<t>
-//!\endcond
-constexpr size_t range_dimension_v = 1;
-
-//!\cond
-template <typename t>
-    requires detail::has_range_value_type<t> && detail::has_range_value_type<std::ranges::range_value_t<std::remove_cvref_t<t>>>
-constexpr size_t range_dimension_v<t> = range_dimension_v<std::ranges::range_value_t<std::remove_cvref_t<t>>> + 1;
-//!\endcond
-
-// ----------------------------------------------------------------------------
-// range_compatible
-// ----------------------------------------------------------------------------
-
-//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
-
-/*!\interface seqan3::range_compatible <>
- * \brief Two types are "compatible" if their seqan3::range_dimension_v and their seqan3::range_innermost_value_t are
- * the same.
- *
- * \details
- *
- * \include test/snippet/core/type_traits/range.cpp
- *
- * Attention, this concept implicitly removes cv-qualifiers and reference from the types it recurses on and
- * compares.
- */
-//!\cond
-template <typename t1, typename t2>
-SEQAN3_CONCEPT range_compatible = requires (t1, t2)
-{
-    requires (range_dimension_v<t1> == range_dimension_v<t2>);
-
-    requires std::is_same_v<range_innermost_value_t<t1>, range_innermost_value_t<t2>>;
-};
-//!\endcond
-
-//!\}
-
-} // namespace seqan3
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/core/range/type_traits.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/template_inspection.hpp b/include/seqan3/core/type_traits/template_inspection.hpp
index a3f272a930..a1000f2475 100644
--- a/include/seqan3/core/type_traits/template_inspection.hpp
+++ b/include/seqan3/core/type_traits/template_inspection.hpp
@@ -6,244 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
- * \brief Provides seqan3::type_list and auxiliary type traits.
+ * \brief [DEPRECATED] Provides seqan3::type_list and auxiliary type traits.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/core/detail/template_inspection.hpp> instead.
  */
 
 #pragma once
 
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
-#include <seqan3/std/concepts>
-
-namespace seqan3::detail
-{
-
-// ----------------------------------------------------------------------------
-// transfer_template_args_onto
-// ----------------------------------------------------------------------------
-
-//!\cond
-template <typename source_type, template <typename ...> typename target_template>
-struct transfer_template_args_onto
-{};
-//!\endcond
-
-/*!\brief Extracts a type template's **type** arguments and specialises another template with them.
- * \implements seqan3::transformation_trait
- * \ingroup type_traits
- * \tparam source_template   The source type; must be a specialisation of a template.
- * \tparam target_template   The type template you wish to specialise.
- * \tparam source_arg_types  The **type** arguments to the source_template (deduced implicitly).
- * \see seqan3::detail::transfer_template_vargs_onto
- *
- * \details
- *
- * Among other use cases, it enables using the types contained in a seqan3::type_list to specialise another type
- * template.
- *
- * A type trait shortcut is also defined: seqan3::detail::transfer_template_args_onto_t
- *
- * This type trait works for templates that have **only type-arguments**. See
- * seqan3::detail::transfer_template_vargs_onto for a type trait that transfers non-type arguments. There is
- * no type trait that can handle a combination of type and non-type arguments.
- * If the `source_type` is a not a template class, e.g. an `int`, the member type `type` is not defined.
- *
- * ### Example
- *
- * \include test/snippet/core/type_traits/template_inspection_usage.cpp
- */
-template <template <typename ...> typename source_template,
-          template <typename ...> typename target_template,
-          typename ...source_arg_types>
-//!\cond
-    requires requires ()
-    {
-        typename target_template<source_arg_types...>;
-    }
-//!\endcond
-struct transfer_template_args_onto<source_template<source_arg_types...>, target_template>
-{
-    //!\brief The return type: the target type specialised by the unpacked types in the list.
-    using type = target_template<source_arg_types...>;
-};
-
-/*!\brief Shortcut for seqan3::detail::transfer_template_args_onto (transformation_trait shortcut).
- * \ingroup type_traits
- * \see seqan3::detail::transfer_template_args_onto
- */
-template <typename source_type, template <typename ...> typename target_template>
-using transfer_template_args_onto_t = typename transfer_template_args_onto<source_type, target_template>::type;
-
-// ----------------------------------------------------------------------------
-// transfer_template_vargs_onto
-// ----------------------------------------------------------------------------
-
-//!\cond
-template <typename source_type, template <auto ...> typename target_template>
-struct transfer_template_vargs_onto
-{};
-//!\endcond
-
-/*!\brief Extracts a type template's **non-type** arguments and specialises another template with them.
- * \implements seqan3::transformation_trait
- * \ingroup type_traits
- * \tparam source_template   The source type; must be a specialisation of a template.
- * \tparam target_template   The type template you wish to specialise.
- * \tparam source_varg_types The **non-type** arguments to the source_template (deduced implicitly).
- * \see seqan3::detail::transfer_template_vargs_onto
- *
- * \details
- *
- * A shortcut is also defined: seqan3::detail::transfer_template_vargs_onto_t
- *
- * This transformation trait works for templates that have **only non-type-arguments**. See
- * seqan3::detail::transfer_template_args_onto for a transformation trait that transfers type arguments. There is
- * no transformation trait that can handle a combination of type and non-type arguments.
- * If the `source_type` is a not a template class, e.g. an `int`, the member type `type` is not defined.
- */
-template <template <auto ...> typename source_template,
-          template <auto ...> typename target_template,
-          auto ... source_varg_types>
-//!\cond
-    requires requires ()
-    {
-        typename target_template<source_varg_types...>;
-    }
-//!\endcond
-struct transfer_template_vargs_onto<source_template<source_varg_types...>, target_template>
-{
-    //!\brief The return type: the target type specialised by the unpacked types in the list.
-    using type = target_template<source_varg_types...>;
-};
-
-/*!\brief Shortcut for seqan3::detail::transfer_template_vargs_onto (transformation_trait shortcut).
- * \ingroup type_traits
- * \see seqan3::detail::transfer_template_vargs_onto
- */
-template <typename source_type, template <auto ...> typename target_template>
-using transfer_template_vargs_onto_t = typename transfer_template_vargs_onto<source_type, target_template>::type;
-
-// ----------------------------------------------------------------------------
-// is_type_specialisation_of_v
-// ----------------------------------------------------------------------------
-
-/*!\brief Determines whether a source_type is a specialisation of another template.
- * \implements seqan3::unary_type_trait
- * \ingroup type_traits
- * \tparam source_type      The source type.
- * \tparam target_template  The type template you wish to compare against (must take only types as template arguments).
- *
- * \details
- *
- * ### Example
- *
- * \include test/snippet/core/type_traits/template_inspection_usage_2.cpp
- */
-template <typename source_t, template <typename ...> typename target_template>
-struct is_type_specialisation_of : public std::false_type
-{};
-
-//!\overload
-template <typename source_t, template <typename ...> typename target_template>
-//!\cond
-    requires (!std::same_as<transformation_trait_or_t<transfer_template_args_onto<source_t, target_template>, void>,
-                            void>)
-//!\endcond
-struct is_type_specialisation_of<source_t, target_template> :
-        std::is_same<source_t, transfer_template_args_onto_t<source_t, target_template>>
-{};
-
-/*!\brief Helper variable template for seqan3::detail::is_type_specialisation_of (unary_type_trait shortcut).
- * \relates seqan3::detail::is_type_specialisation_of
- * \tparam source_type      The source type.
- * \tparam target_template  The type template you wish to compare against (must take only types as template arguments).
- */
-template <typename source_t, template <typename ...> typename target_template>
-inline constexpr bool is_type_specialisation_of_v = is_type_specialisation_of<source_t, target_template>::value;
-
-// ----------------------------------------------------------------------------
-// is_value_specialisation_of_v
-// ----------------------------------------------------------------------------
-
-//!\cond
-template <typename source_t, template <auto ...> typename target_template>
-struct is_value_specialisation_of : std::false_type
-{};
-//!\endcond
-
-/*!\brief Determines whether a source_type is a specialisation of another template.
- * \implements seqan3::unary_type_trait
- * \ingroup type_traits
- * \tparam source_type      The source type.
- * \tparam target_template  The type template you wish to compare against (must take only non-types as template
- * arguments).
- * \see seqan3::detail::is_type_specialisation_of
- * \see seqan3::detail::is_value_specialisation_of_v
- */
-template <typename source_t, template <auto ...> typename target_template>
-//!\cond
-    requires (!std::same_as<transformation_trait_or_t<transfer_template_vargs_onto<source_t, target_template>, void>,
-                            void>)
-//!\endcond
-struct is_value_specialisation_of<source_t, target_template> :
-    std::is_same<source_t, transfer_template_vargs_onto_t<source_t, target_template>>
-{};
-
-/*!\brief Helper variable template for seqan3::detail::is_value_specialisation_of (unary_type_trait shortcut).
- * \relates seqan3::detail::is_value_specialisation_of
- * \tparam source_type      The source type.
- * \tparam target_template  The type template you wish to compare against (must take only types as template arguments).
- */
-template <typename source_t, template <auto ...> typename target_template>
-inline constexpr bool is_value_specialisation_of_v = is_value_specialisation_of<source_t, target_template>::value;
-
-/*!
- * \brief Exposes `templ_t<spec_t...>` if that is valid, otherwise `fallback_t`.
- * \implements seqan3::transformation_trait
- * \see seqan3::detail::valid_template_spec_or_t
- * \ingroup type_traits
- * \tparam fallback_t The fallback type.
- * \tparam templ_t    The type template that should be specialised.
- * \tparam spec_t     The specialisation for the type template.
- */
-template <typename fallback_t, template <typename ...> typename templ_t, typename ...spec_t>
-struct valid_template_spec_or
-{
-    //!\brief The resulting type.
-    using type = fallback_t;
-};
-
-//!\overload
-template <typename fallback_t, template <typename ...> typename templ_t, typename ...spec_t>
-//!\cond
-    requires requires { typename templ_t<spec_t...>; }
-//!\endcond
-struct valid_template_spec_or<fallback_t, templ_t, spec_t...>
-{
-    //!\brief The resulting type.
-    using type = templ_t<spec_t...>;
-};
-
-/*!\brief Helper for seqan3::detail::valid_template_spec_or (transformation_trait shortcut).
- * \ingroup type_traits
- * \see seqan3::detail::valid_template_spec_or
- * \tparam fallback_t The fallback type.
- * \tparam templ_t    The type template that should be specialised.
- * \tparam spec_t     The specialisation for the type template.
- */
-template <typename fallback_t, template <typename ...> typename templ_t, typename ...spec_t>
-using valid_template_spec_or_t = typename valid_template_spec_or<fallback_t, templ_t, spec_t...>::type;
-
-// ----------------------------------------------------------------------------
-// strip_type_identity
-// ----------------------------------------------------------------------------
-
-/*!\brief A transformation trait shortcut that returns the type inside a std::type_identity or the type itself.
- * \tparam t The type to operate on.
- */
-template <typename t>
-using strip_type_identity_t = std::conditional_t<is_type_specialisation_of_v<t, std::type_identity>,
-                                                 transformation_trait_or_t<t, void>,
-                                                 t>;
-} // namespace seqan3::detail
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/core/detail/template_inspection.hpp> instead.")
diff --git a/include/seqan3/core/type_traits/transformation_trait_or.hpp b/include/seqan3/core/type_traits/transformation_trait_or.hpp
index 15580f82c7..d6063752a9 100644
--- a/include/seqan3/core/type_traits/transformation_trait_or.hpp
+++ b/include/seqan3/core/type_traits/transformation_trait_or.hpp
@@ -6,49 +6,13 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \author Marcel Ehrhardt <marcel.ehrhardt AT fu-berlin.de>
- * \brief Provides seqan3::detail::transformation_trait_or.
+ * \brief [DEPRECATED] Provides seqan3::detail::transformation_trait_or.
+ * \deprecated This header is deprecated and will be removed in SeqAn-3.1.
+ *             Please \#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp> instead.
  */
 
 #pragma once
 
-#include <type_traits>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
-#include <seqan3/core/type_traits/concept.hpp>
-#include <seqan3/std/type_traits>
-
-namespace seqan3::detail
-{
-
-/*!\brief This gives a fallback type if *type_t::type* is not defined.
- * \implements seqan3::transformation_trait
- * \ingroup type_traits
- * \tparam type_t    The type to use if *type_t::type* is defined.
- * \tparam default_t The type to use otherwise.
- * \see seqan3::detail::transformation_trait_or_t
- *
- * \details
- *
- * Gives *type_t* back if *T::type* is a member type, otherwise *struct{using type = default_t}*.
- *
- * \include test/snippet/core/type_traits/transformation_trait_or.cpp
- *
- * \attention This might get removed if one of our used libraries offers the same
- * functionality.
- *
- * ###Helper types
- *   seqan3::detail::transformation_trait_or_t as a shorthand for *seqan3::detail::transformation_trait_or::type*
- */
-template <typename type_t, typename default_t>
-using transformation_trait_or = std::conditional_t<transformation_trait<type_t>,    // check if type_t::type exists
-                                                   type_t,                          // if yes, return type_t
-                                                   std::type_identity<default_t>>;  // else return default_t as trait
-
-/*!\brief Helper type of seqan3::detail::transformation_trait_or (transformation_trait shortcut).
- * \ingroup type_traits
- * \see seqan3::detail::transformation_trait_or
- */
-template <typename type_t, typename default_t>
-using transformation_trait_or_t = typename transformation_trait_or<type_t, default_t>::type;
-
-} // namespace seqan3::detail
+SEQAN3_DEPRECATED_HEADER("This header is deprecated and will be removed in SeqAn-3.1. Please #include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp> instead.")
diff --git a/include/seqan3/io/alignment_file/format_bam.hpp b/include/seqan3/io/alignment_file/format_bam.hpp
index 98f0717a10..0f60ff92df 100644
--- a/include/seqan3/io/alignment_file/format_bam.hpp
+++ b/include/seqan3/io/alignment_file/format_bam.hpp
@@ -25,8 +25,8 @@
 #include <seqan3/core/concept/tuple.hpp>
 #include <seqan3/core/debug_stream/detail/to_string.hpp>
 #include <seqan3/core/detail/debug_stream_optional.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/alignment_file/detail.hpp>
 #include <seqan3/io/alignment_file/format_sam_base.hpp>
 #include <seqan3/io/alignment_file/header.hpp>
diff --git a/include/seqan3/io/alignment_file/format_sam.hpp b/include/seqan3/io/alignment_file/format_sam.hpp
index 9ef85d9f4c..a262cd9d3d 100644
--- a/include/seqan3/io/alignment_file/format_sam.hpp
+++ b/include/seqan3/io/alignment_file/format_sam.hpp
@@ -22,8 +22,8 @@
 #include <seqan3/core/concept/core_language.hpp>
 #include <seqan3/core/concept/tuple.hpp>
 #include <seqan3/core/debug_stream/detail/to_string.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/alignment_file/detail.hpp>
 #include <seqan3/io/alignment_file/format_sam_base.hpp>
 #include <seqan3/io/alignment_file/header.hpp>
diff --git a/include/seqan3/io/alignment_file/format_sam_base.hpp b/include/seqan3/io/alignment_file/format_sam_base.hpp
index b39ec1d633..16a39ac01d 100644
--- a/include/seqan3/io/alignment_file/format_sam_base.hpp
+++ b/include/seqan3/io/alignment_file/format_sam_base.hpp
@@ -24,8 +24,8 @@
 #include <seqan3/core/concept/tuple.hpp>
 #include <seqan3/core/debug_stream/detail/to_string.hpp>
 #include <seqan3/core/detail/debug_stream_range.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/alignment_file/detail.hpp>
 #include <seqan3/io/alignment_file/header.hpp>
 #include <seqan3/io/alignment_file/input_format_concept.hpp>
diff --git a/include/seqan3/io/alignment_file/header.hpp b/include/seqan3/io/alignment_file/header.hpp
index cbf53e3bcd..423b253ac1 100644
--- a/include/seqan3/io/alignment_file/header.hpp
+++ b/include/seqan3/io/alignment_file/header.hpp
@@ -13,15 +13,15 @@
 #pragma once
 
 #include <deque>
+#include <seqan3/std/ranges>
 #include <unordered_map>
 #include <vector>
 
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/pre.hpp>
 #include <seqan3/io/alignment_file/detail.hpp>
 #include <seqan3/range/hash.hpp>
 #include <seqan3/range/views/type_reduce.hpp>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/pre.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/io/alignment_file/input.hpp b/include/seqan3/io/alignment_file/input.hpp
index 522c52ee70..9fcbfc77ef 100644
--- a/include/seqan3/io/alignment_file/input.hpp
+++ b/include/seqan3/io/alignment_file/input.hpp
@@ -29,7 +29,6 @@
 #include <seqan3/alphabet/quality/phred42.hpp>
 #include <seqan3/alphabet/quality/qualified.hpp>
 #include <seqan3/core/concept/tuple.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/io/alignment_file/input_format_concept.hpp>
 #include <seqan3/io/alignment_file/format_bam.hpp>
 #include <seqan3/io/alignment_file/format_sam.hpp>
@@ -44,6 +43,7 @@
 #include <seqan3/range/views/repeat_n.hpp>
 #include <seqan3/range/views/slice.hpp>
 #include <seqan3/utility/type_list/traits.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/io/alignment_file/sam_tag_dictionary.hpp b/include/seqan3/io/alignment_file/sam_tag_dictionary.hpp
index 853dc7e36a..12992c023c 100644
--- a/include/seqan3/io/alignment_file/sam_tag_dictionary.hpp
+++ b/include/seqan3/io/alignment_file/sam_tag_dictionary.hpp
@@ -17,7 +17,7 @@
 #include <variant>
 
 #include <seqan3/core/concept/core_language.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/range/container/small_string.hpp>
 #include <seqan3/utility/char_operations/predicate.hpp>
 
diff --git a/include/seqan3/io/detail/magic_header.hpp b/include/seqan3/io/detail/magic_header.hpp
index 9723d79357..4985aa0631 100644
--- a/include/seqan3/io/detail/magic_header.hpp
+++ b/include/seqan3/io/detail/magic_header.hpp
@@ -20,7 +20,7 @@
 
 #include <seqan3/core/bit_manipulation.hpp>
 #include <seqan3/core/concept/core_language.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/utility/type_pack/traits.hpp>
 
 namespace seqan3::detail
diff --git a/include/seqan3/io/detail/misc.hpp b/include/seqan3/io/detail/misc.hpp
index a78b053f1b..c59549975c 100644
--- a/include/seqan3/io/detail/misc.hpp
+++ b/include/seqan3/io/detail/misc.hpp
@@ -15,7 +15,7 @@
 #include <variant>
 
 #include <seqan3/core/detail/pack_algorithm.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/io/exception.hpp>
 #include <seqan3/std/algorithm>
 #include <seqan3/std/filesystem>
diff --git a/include/seqan3/io/record.hpp b/include/seqan3/io/record.hpp
index 67460ab42e..6c3d3fc25f 100644
--- a/include/seqan3/io/record.hpp
+++ b/include/seqan3/io/record.hpp
@@ -14,7 +14,7 @@
 
 #include <tuple>
 
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/io/sequence_file/format_embl.hpp b/include/seqan3/io/sequence_file/format_embl.hpp
index 161ce98624..9d642e650b 100644
--- a/include/seqan3/io/sequence_file/format_embl.hpp
+++ b/include/seqan3/io/sequence_file/format_embl.hpp
@@ -20,7 +20,7 @@
 #include <vector>
 
 #include <seqan3/alphabet/nucleotide/dna5.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/detail/misc.hpp>
 #include <seqan3/io/sequence_file/input_format_concept.hpp>
 #include <seqan3/io/sequence_file/input_options.hpp>
diff --git a/include/seqan3/io/sequence_file/format_fasta.hpp b/include/seqan3/io/sequence_file/format_fasta.hpp
index 0dfb29aa75..02d0354073 100644
--- a/include/seqan3/io/sequence_file/format_fasta.hpp
+++ b/include/seqan3/io/sequence_file/format_fasta.hpp
@@ -22,7 +22,7 @@
 #include <seqan3/alphabet/adaptation/char.hpp>
 #include <seqan3/alphabet/nucleotide/dna5.hpp>
 #include <seqan3/alphabet/quality/aliases.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/detail/ignore_output_iterator.hpp>
 #include <seqan3/io/detail/misc.hpp>
 #include <seqan3/io/sequence_file/input_format_concept.hpp>
diff --git a/include/seqan3/io/sequence_file/format_fastq.hpp b/include/seqan3/io/sequence_file/format_fastq.hpp
index 9b0df4bd9d..b07a0286de 100644
--- a/include/seqan3/io/sequence_file/format_fastq.hpp
+++ b/include/seqan3/io/sequence_file/format_fastq.hpp
@@ -22,7 +22,7 @@
 #include <seqan3/alphabet/adaptation/char.hpp>
 #include <seqan3/alphabet/nucleotide/dna5.hpp>
 #include <seqan3/alphabet/quality/aliases.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/detail/ignore_output_iterator.hpp>
 #include <seqan3/io/detail/misc.hpp>
 #include <seqan3/io/sequence_file/input_format_concept.hpp>
diff --git a/include/seqan3/io/sequence_file/format_genbank.hpp b/include/seqan3/io/sequence_file/format_genbank.hpp
index 9937fb9e3e..4356a0e8a0 100644
--- a/include/seqan3/io/sequence_file/format_genbank.hpp
+++ b/include/seqan3/io/sequence_file/format_genbank.hpp
@@ -15,15 +15,15 @@
 #include <seqan3/std/algorithm>
 #include <seqan3/std/charconv>
 #include <iterator>
-#include <string>
 #include <seqan3/std/ranges>
+#include <string>
 #include <string_view>
 #include <vector>
 
 #include <range/v3/view/chunk.hpp>
 
 #include <seqan3/alphabet/nucleotide/dna5.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/detail/misc.hpp>
 #include <seqan3/io/sequence_file/input_format_concept.hpp>
 #include <seqan3/io/sequence_file/input_options.hpp>
diff --git a/include/seqan3/io/structure_file/format_vienna.hpp b/include/seqan3/io/structure_file/format_vienna.hpp
index f3f7ba5d6a..dcded29be4 100644
--- a/include/seqan3/io/structure_file/format_vienna.hpp
+++ b/include/seqan3/io/structure_file/format_vienna.hpp
@@ -24,7 +24,7 @@
 
 #include <seqan3/alphabet/adaptation/char.hpp>
 #include <seqan3/alphabet/structure/wuss.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/detail/misc.hpp>
 #include <seqan3/io/stream/iterator.hpp>
 #include <seqan3/io/structure_file/detail.hpp>
diff --git a/include/seqan3/range/container/concatenated_sequences.hpp b/include/seqan3/range/container/concatenated_sequences.hpp
index e7437f8385..eac5434e90 100644
--- a/include/seqan3/range/container/concatenated_sequences.hpp
+++ b/include/seqan3/range/container/concatenated_sequences.hpp
@@ -179,7 +179,8 @@ class concatenated_sequences
 
 protected:
     /*!\name Compatibility
-     * \brief Static constexpr variables that emulate/encapsulate seqan3::range_compatible (which doesn't work for types during their definition).
+     * \brief Static constexpr variables that emulate whether the ranges are compatible
+     *        (which doesn't work for types during their definition).
      * \{
      */
     //!\cond
@@ -197,13 +198,13 @@ class concatenated_sequences
     }
     //!\endcond
 
-    //!\brief Whether a type satisfies seqan3::range_compatible with this class's `value_type` or `reference` type.
+    //!\brief Whether a type is compatible with this class's `value_type` or `reference` type.
     //!\hideinitializer
     // we explicitly check same-ness, because these types may not be fully resolved, yet
     template <std::ranges::range t>
     static constexpr bool is_compatible_with_value_type = is_compatible_with_value_type_aux(std::type_identity<t>{});
 
-    //!\brief Whether a type satisfies seqan3::range_compatible with this class.
+    //!\brief Whether a type is compatible with this class.
     //!\hideinitializer
     // cannot use the concept, because this class is not yet fully defined
     template <typename t>
@@ -212,7 +213,7 @@ class concatenated_sequences
     //!\endcond
     static constexpr bool iter_value_t_is_compatible_with_value_type = true;
 
-    //!\brief Whether a type satisfies seqan3::range_compatible with this class.
+    //!\brief Whether a type is compatible with this class.
     //!\hideinitializer
     // cannot use the concept, because this class is not yet fully defined
     template <std::ranges::range t>
diff --git a/include/seqan3/range/container/small_vector.hpp b/include/seqan3/range/container/small_vector.hpp
index a768484441..6306e301aa 100644
--- a/include/seqan3/range/container/small_vector.hpp
+++ b/include/seqan3/range/container/small_vector.hpp
@@ -20,7 +20,7 @@
 #endif // SEQAN3_WITH_CEREAL
 
 #include <seqan3/core/concept/cereal.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/range/views/repeat_n.hpp>
 #include <seqan3/utility/detail/integer_traits.hpp>
 
diff --git a/include/seqan3/range/detail/inherited_iterator_base.hpp b/include/seqan3/range/detail/inherited_iterator_base.hpp
index ef77e75dbe..bec7be7b5c 100644
--- a/include/seqan3/range/detail/inherited_iterator_base.hpp
+++ b/include/seqan3/range/detail/inherited_iterator_base.hpp
@@ -13,11 +13,11 @@
 #pragma once
 
 #include <cassert>
+#include <seqan3/std/iterator>
 #include <type_traits>
 
 #include <seqan3/core/detail/empty_type.hpp>
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/std/iterator>
+#include <seqan3/core/detail/iterator_traits.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/hash.hpp b/include/seqan3/range/hash.hpp
index 4bebc88ccb..fd40a5f2ef 100644
--- a/include/seqan3/range/hash.hpp
+++ b/include/seqan3/range/hash.hpp
@@ -12,10 +12,11 @@
 
 #pragma once
 
+#include <seqan3/std/ranges>
+
 #include <seqan3/alphabet/hash.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/concept.hpp>
-#include <seqan3/std/ranges>
 
 namespace std
 {
diff --git a/include/seqan3/range/views/as_const.hpp b/include/seqan3/range/views/as_const.hpp
index 6f5a0c0a3e..ed2da595ea 100644
--- a/include/seqan3/range/views/as_const.hpp
+++ b/include/seqan3/range/views/as_const.hpp
@@ -12,9 +12,10 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/function.hpp>
 #include <seqan3/std/ranges>
 
+#include <seqan3/utility/type_traits/function_traits.hpp>
+
 namespace seqan3::detail
 {
 
diff --git a/include/seqan3/range/views/char_to.hpp b/include/seqan3/range/views/char_to.hpp
index f70d8a5e01..d723546e6f 100644
--- a/include/seqan3/range/views/char_to.hpp
+++ b/include/seqan3/range/views/char_to.hpp
@@ -12,10 +12,11 @@
 
 #pragma once
 
+#include <seqan3/std/ranges>
+
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/range/views/deep.hpp>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::views
 {
diff --git a/include/seqan3/range/views/detail.hpp b/include/seqan3/range/views/detail.hpp
index 796374f774..52443b7747 100644
--- a/include/seqan3/range/views/detail.hpp
+++ b/include/seqan3/range/views/detail.hpp
@@ -13,11 +13,11 @@
 
 #pragma once
 
+#include <seqan3/std/ranges>
 #include <tuple>
 
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/std/ranges>
+#include <seqan3/core/range/type_traits.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/views/drop.hpp b/include/seqan3/range/views/drop.hpp
index 749bfbf640..87b5fb891c 100644
--- a/include/seqan3/range/views/drop.hpp
+++ b/include/seqan3/range/views/drop.hpp
@@ -12,16 +12,17 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/io/exception.hpp>
-#include <seqan3/range/concept.hpp>
-#include <seqan3/range/views/detail.hpp>
 #include <seqan3/std/concepts>
 #include <seqan3/std/iterator>
 #include <seqan3/std/ranges>
 #include <seqan3/std/span>
 #include <seqan3/std/type_traits>
 
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/io/exception.hpp>
+#include <seqan3/range/concept.hpp>
+#include <seqan3/range/views/detail.hpp>
+
 namespace seqan3::detail
 {
 
diff --git a/include/seqan3/range/views/get.hpp b/include/seqan3/range/views/get.hpp
index 5c564dd865..59f6c5503e 100644
--- a/include/seqan3/range/views/get.hpp
+++ b/include/seqan3/range/views/get.hpp
@@ -12,10 +12,11 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/core/concept/tuple.hpp>
 #include <seqan3/std/ranges>
 
+#include <seqan3/core/concept/tuple.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
+
 namespace seqan3::views
 {
 /*!\name General purpose views
diff --git a/include/seqan3/range/views/interleave.hpp b/include/seqan3/range/views/interleave.hpp
index 8538cd816e..81784f370f 100644
--- a/include/seqan3/range/views/interleave.hpp
+++ b/include/seqan3/range/views/interleave.hpp
@@ -13,18 +13,18 @@
 #pragma once
 
 #include <cmath>
+#include <seqan3/std/concepts>
+#include <seqan3/std/ranges>
 
 #include <range/v3/view/chunk.hpp>
 
-#include <seqan3/core/type_traits/pre.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/range/detail/random_access_iterator.hpp>
 #include <seqan3/range/views/detail.hpp>
 #include <seqan3/range/views/join.hpp>
 #include <seqan3/range/views/persist.hpp>
 #include <seqan3/range/views/type_reduce.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
+#include <seqan3/utility/type_traits/pre.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/views/minimiser.hpp b/include/seqan3/range/views/minimiser.hpp
index d4968a7f49..bc46bccb5d 100644
--- a/include/seqan3/range/views/minimiser.hpp
+++ b/include/seqan3/range/views/minimiser.hpp
@@ -16,9 +16,9 @@
 #include <deque>
 
 #include <seqan3/core/detail/empty_type.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
 #include <seqan3/range/concept.hpp>
 #include <seqan3/range/views/detail.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/views/move.hpp b/include/seqan3/range/views/move.hpp
index 7d2d2f6689..84832b859f 100644
--- a/include/seqan3/range/views/move.hpp
+++ b/include/seqan3/range/views/move.hpp
@@ -12,8 +12,10 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/function.hpp>
 #include <seqan3/std/ranges>
+#include <seqan3/std/type_traits>
+
+#include <seqan3/utility/detail/multi_invocable.hpp>
 
 namespace seqan3::views
 {
diff --git a/include/seqan3/range/views/pairwise_combine.hpp b/include/seqan3/range/views/pairwise_combine.hpp
index a4b922a38d..bb8faf9981 100644
--- a/include/seqan3/range/views/pairwise_combine.hpp
+++ b/include/seqan3/range/views/pairwise_combine.hpp
@@ -13,12 +13,12 @@
 #pragma once
 
 #include <cmath>
+#include <seqan3/std/ranges>
 
 #include <seqan3/core/common_tuple.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/range/concept.hpp>
 #include <seqan3/range/views/detail.hpp>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/views/persist.hpp b/include/seqan3/range/views/persist.hpp
index acc5a56dd2..1922080165 100644
--- a/include/seqan3/range/views/persist.hpp
+++ b/include/seqan3/range/views/persist.hpp
@@ -16,13 +16,13 @@
 #include <seqan3/std/concepts>
 #include <seqan3/std/ranges>
 
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/exception.hpp>
 #include <seqan3/range/concept.hpp>
 #include <seqan3/range/container/concept.hpp>
 #include <seqan3/range/views/detail.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/views/repeat.hpp b/include/seqan3/range/views/repeat.hpp
index 5ef0b6881a..ba77760038 100644
--- a/include/seqan3/range/views/repeat.hpp
+++ b/include/seqan3/range/views/repeat.hpp
@@ -15,8 +15,8 @@
 #include <seqan3/std/algorithm>
 #include <seqan3/std/ranges>
 
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/detail/random_access_iterator.hpp>
 
 namespace seqan3::detail
diff --git a/include/seqan3/range/views/take.hpp b/include/seqan3/range/views/take.hpp
index 6215a4bc64..372c8343dd 100644
--- a/include/seqan3/range/views/take.hpp
+++ b/include/seqan3/range/views/take.hpp
@@ -19,15 +19,15 @@
 #include <seqan3/std/span>
 #include <seqan3/std/type_traits>
 
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/io/exception.hpp>
 #include <seqan3/range/concept.hpp>
 #include <seqan3/range/container/concept.hpp>
 #include <seqan3/range/views/detail.hpp>
 #include <seqan3/range/detail/inherited_iterator_base.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3::detail
 {
@@ -430,7 +430,7 @@ class view_take<urng_t, exactly, or_throw>::basic_iterator :
     }
 
     //!\brief Checks whether `lhs` is not equal to `rhs`.
-    constexpr friend bool operator!=(sentinel_type const & lhs, basic_iterator const & rhs) 
+    constexpr friend bool operator!=(sentinel_type const & lhs, basic_iterator const & rhs)
         noexcept(noexcept(rhs != lhs))
     {
         return rhs != lhs;
diff --git a/include/seqan3/range/views/take_until.hpp b/include/seqan3/range/views/take_until.hpp
index b454dfaf38..63cd331095 100644
--- a/include/seqan3/range/views/take_until.hpp
+++ b/include/seqan3/range/views/take_until.hpp
@@ -12,22 +12,21 @@
 
 #pragma once
 
+#include <seqan3/std/algorithm>
+#include <seqan3/std/concepts>
+#include <seqan3/std/iterator>
+#include <seqan3/std/ranges>
+#include <seqan3/std/type_traits>
+
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/core/semiregular_box.hpp>
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/io/exception.hpp>
 #include <seqan3/range/concept.hpp>
 #include <seqan3/range/views/detail.hpp>
 #include <seqan3/range/detail/inherited_iterator_base.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
 #include <seqan3/range/container/concept.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/concepts>
-#include <seqan3/std/iterator>
-#include <seqan3/std/type_traits>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/views/translate.hpp b/include/seqan3/range/views/translate.hpp
index 42f94e4404..ea74acd78a 100644
--- a/include/seqan3/range/views/translate.hpp
+++ b/include/seqan3/range/views/translate.hpp
@@ -12,6 +12,8 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+#include <seqan3/std/ranges>
 #include <vector>
 #include <stdexcept>
 
@@ -19,13 +21,11 @@
 #include <seqan3/alphabet/aminoacid/aa27.hpp>
 #include <seqan3/alphabet/aminoacid/translation.hpp>
 #include <seqan3/core/add_enum_bitwise_operators.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/container/small_string.hpp>
 #include <seqan3/range/detail/random_access_iterator.hpp>
 #include <seqan3/range/views/deep.hpp>
 #include <seqan3/range/views/detail.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
 #include <seqan3/range/container/concept.hpp>
 
 // ============================================================================
@@ -546,7 +546,8 @@ class view_translate : public std::ranges::view_base
 
 protected:
     /*!\name Compatibility
-     * \brief Static constexpr variables that emulate/encapsulate seqan3::range_compatible (which doesn't work for types during their definition).
+     * \brief Static constexpr variables that emulate whether the ranges are compatible
+     *        (which doesn't work for types during their definition).
      * \{
      */
     //!\cond
diff --git a/include/seqan3/range/views/translate_join.hpp b/include/seqan3/range/views/translate_join.hpp
index 418b0a976e..b848bd5d9f 100644
--- a/include/seqan3/range/views/translate_join.hpp
+++ b/include/seqan3/range/views/translate_join.hpp
@@ -12,15 +12,15 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+#include <seqan3/std/ranges>
 #include <vector>
 #include <stdexcept>
 
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/container/small_string.hpp>
 #include <seqan3/range/detail/random_access_iterator.hpp>
 #include <seqan3/range/views/translate.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/range/views/type_reduce.hpp b/include/seqan3/range/views/type_reduce.hpp
index a69ec283bb..9c4cc49bd1 100644
--- a/include/seqan3/range/views/type_reduce.hpp
+++ b/include/seqan3/range/views/type_reduce.hpp
@@ -12,14 +12,14 @@
 
 #pragma once
 
+#include <seqan3/std/concepts>
+#include <seqan3/std/ranges>
+#include <seqan3/std/span>
 #include <string_view>
 
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/range/concept.hpp>
 #include <seqan3/range/views/detail.hpp>
-#include <seqan3/std/concepts>
-#include <seqan3/std/ranges>
-#include <seqan3/std/span>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/search/configuration/result_type.hpp b/include/seqan3/search/configuration/result_type.hpp
index 6323030007..593c6afc5d 100644
--- a/include/seqan3/search/configuration/result_type.hpp
+++ b/include/seqan3/search/configuration/result_type.hpp
@@ -15,7 +15,7 @@
 #include <seqan3/std/type_traits>
 
 #include <seqan3/core/algorithm/pipeable_config_element.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/search/configuration/detail.hpp>
 #include <seqan3/search/search_result.hpp>
 
diff --git a/include/seqan3/search/detail/policy_search_result_builder.hpp b/include/seqan3/search/detail/policy_search_result_builder.hpp
index ba961da70c..a342265f85 100644
--- a/include/seqan3/search/detail/policy_search_result_builder.hpp
+++ b/include/seqan3/search/detail/policy_search_result_builder.hpp
@@ -12,7 +12,7 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/search/detail/search_traits.hpp>
 #include <seqan3/search/fm_index/concept.hpp>
 #include <seqan3/search/search_result.hpp>
diff --git a/include/seqan3/search/detail/search_configurator.hpp b/include/seqan3/search/detail/search_configurator.hpp
index 267644c9a4..63637e84f5 100644
--- a/include/seqan3/search/detail/search_configurator.hpp
+++ b/include/seqan3/search/detail/search_configurator.hpp
@@ -12,9 +12,7 @@
 
 #pragma once
 
-#include <seqan3/core/type_traits/function.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/search/configuration/hit.hpp>
 #include <seqan3/search/configuration/max_error.hpp>
 #include <seqan3/search/configuration/output.hpp>
@@ -24,6 +22,8 @@
 #include <seqan3/search/detail/search_scheme_algorithm.hpp>
 #include <seqan3/search/detail/unidirectional_search_algorithm.hpp>
 #include <seqan3/search/search_result.hpp>
+#include <seqan3/utility/detail/multi_invocable.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/search/detail/search_scheme_algorithm.hpp b/include/seqan3/search/detail/search_scheme_algorithm.hpp
index 2c004f00a4..510576c271 100644
--- a/include/seqan3/search/detail/search_scheme_algorithm.hpp
+++ b/include/seqan3/search/detail/search_scheme_algorithm.hpp
@@ -14,12 +14,12 @@
 
 #include <type_traits>
 
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
 #include <seqan3/range/views/slice.hpp>
 #include <seqan3/search/detail/search_common.hpp>
 #include <seqan3/search/detail/search_scheme_precomputed.hpp>
 #include <seqan3/search/detail/search_traits.hpp>
 #include <seqan3/search/fm_index/concept.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/search/detail/search_traits.hpp b/include/seqan3/search/detail/search_traits.hpp
index d27ab25fb4..4e21c1e5ee 100644
--- a/include/seqan3/search/detail/search_traits.hpp
+++ b/include/seqan3/search/detail/search_traits.hpp
@@ -14,12 +14,12 @@
 #pragma once
 
 #include <seqan3/core/detail/empty_type.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/search/configuration/max_error.hpp>
 #include <seqan3/search/configuration/hit.hpp>
 #include <seqan3/search/configuration/on_result.hpp>
 #include <seqan3/search/configuration/output.hpp>
 #include <seqan3/search/configuration/result_type.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/search/fm_index/bi_fm_index.hpp b/include/seqan3/search/fm_index/bi_fm_index.hpp
index e3fa2a8df4..fdc5952ae2 100644
--- a/include/seqan3/search/fm_index/bi_fm_index.hpp
+++ b/include/seqan3/search/fm_index/bi_fm_index.hpp
@@ -12,14 +12,14 @@
 
 #pragma once
 
+#include <seqan3/std/filesystem>
+#include <seqan3/std/ranges>
 #include <utility>
 
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/std/filesystem>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/persist.hpp>
 #include <seqan3/search/fm_index/fm_index.hpp>
 #include <seqan3/search/fm_index/bi_fm_index_cursor.hpp>
-#include <seqan3/std/ranges>
 
 namespace seqan3
 {
diff --git a/include/seqan3/search/fm_index/bi_fm_index_cursor.hpp b/include/seqan3/search/fm_index/bi_fm_index_cursor.hpp
index 525e4478fe..b458bb4308 100644
--- a/include/seqan3/search/fm_index/bi_fm_index_cursor.hpp
+++ b/include/seqan3/search/fm_index/bi_fm_index_cursor.hpp
@@ -13,17 +13,17 @@
 #pragma once
 
 #include <array>
+#include <seqan3/std/ranges>
 
 #include <sdsl/suffix_trees.hpp>
 
 #include <seqan3/alphabet/adaptation/char.hpp>
 #include <seqan3/alphabet/adaptation/uint.hpp>
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/slice.hpp>
 #include <seqan3/search/fm_index/fm_index.hpp>
 #include <seqan3/search/fm_index/fm_index_cursor.hpp>
-#include <seqan3/std/ranges>
 
 namespace seqan3
 {
diff --git a/include/seqan3/search/fm_index/concept.hpp b/include/seqan3/search/fm_index/concept.hpp
index 73fd2f80b9..f6b24df804 100644
--- a/include/seqan3/search/fm_index/concept.hpp
+++ b/include/seqan3/search/fm_index/concept.hpp
@@ -16,7 +16,7 @@
 
 #include <sdsl/suffix_arrays.hpp>
 
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/concept.hpp>
 #include <seqan3/range/container/concept.hpp>
 
diff --git a/include/seqan3/search/fm_index/fm_index.hpp b/include/seqan3/search/fm_index/fm_index.hpp
index f7fed97ba4..03a341bdc5 100644
--- a/include/seqan3/search/fm_index/fm_index.hpp
+++ b/include/seqan3/search/fm_index/fm_index.hpp
@@ -12,18 +12,19 @@
 
 #pragma once
 
+#include <seqan3/std/algorithm>
+#include <seqan3/std/filesystem>
+#include <seqan3/std/ranges>
+
 #include <sdsl/suffix_trees.hpp>
 
-#include <seqan3/core/type_traits/range.hpp>
-#include <seqan3/std/filesystem>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/join.hpp>
 #include <seqan3/range/views/to_rank.hpp>
 #include <seqan3/range/views/to.hpp>
 #include <seqan3/search/fm_index/concept.hpp>
 #include <seqan3/search/fm_index/detail/fm_index_cursor.hpp>
 #include <seqan3/search/fm_index/fm_index_cursor.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/ranges>
 
 namespace seqan3::detail
 {
diff --git a/include/seqan3/search/fm_index/fm_index_cursor.hpp b/include/seqan3/search/fm_index/fm_index_cursor.hpp
index 00a7dc46da..7ca1b80956 100644
--- a/include/seqan3/search/fm_index/fm_index_cursor.hpp
+++ b/include/seqan3/search/fm_index/fm_index_cursor.hpp
@@ -20,7 +20,7 @@
 
 #include <seqan3/alphabet/adaptation/char.hpp>
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/slice.hpp>
 #include <seqan3/search/fm_index/concept.hpp>
 #include <seqan3/search/fm_index/detail/fm_index_cursor.hpp>
diff --git a/include/seqan3/search/search_result.hpp b/include/seqan3/search/search_result.hpp
index b9c4715203..02ec3ee680 100644
--- a/include/seqan3/search/search_result.hpp
+++ b/include/seqan3/search/search_result.hpp
@@ -16,10 +16,10 @@
 #include <seqan3/std/concepts>
 #include <exception>
 
+#include <seqan3/core/algorithm/configuration.hpp>
 #include <seqan3/core/detail/debug_stream_type.hpp>
 #include <seqan3/core/detail/empty_type.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/core/algorithm/configuration.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/search/fm_index/concept.hpp>
 
 namespace seqan3::detail
diff --git a/include/seqan3/utility/all.hpp b/include/seqan3/utility/all.hpp
index 4d9a0a836a..d577b04001 100644
--- a/include/seqan3/utility/all.hpp
+++ b/include/seqan3/utility/all.hpp
@@ -6,19 +6,23 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Meta-header for the \link utility utility module \endlink.
+ * \brief Meta-header for the \link utility utility module \endlink, which provides useful, stand-alone features
+ *        that are not strongly coupled with SeqAn3.
+ * \author Jörg Winkler <j.winkler AT fu-berlin.de>
  * \author Rene Rahn <rene.rahn AT fu-berlin.de>
  */
 
 #pragma once
 
+#include <seqan3/utility/math.hpp>
 #include <seqan3/utility/type_list/all.hpp>
 #include <seqan3/utility/type_pack/all.hpp>
-#include <seqan3/utility/math.hpp>
+#include <seqan3/utility/type_traits/all.hpp>
 
 /*!\defgroup utility Utility
  * \brief Provides additional utility functionality used by multiple modules.
  *
+ * \details
  * The utility module contains concepts, functions, traits and classes that
  * are independent of the remaining modules in SeqAn. These implementations
  * are considered external functionality, i.e. they could have been outsourced
diff --git a/include/seqan3/utility/detail/multi_invocable.hpp b/include/seqan3/utility/detail/multi_invocable.hpp
new file mode 100644
index 0000000000..abcbd6008d
--- /dev/null
+++ b/include/seqan3/utility/detail/multi_invocable.hpp
@@ -0,0 +1,37 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides a type that combines multiple invocables.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <functional>
+
+#include <seqan3/core/platform.hpp>
+
+namespace seqan3::detail
+{
+
+/*!\brief A type that can conveniently inherit multiple invocables and acts as a union over them.
+ * \tparam invocable_ts The types to inherit from.
+ * \ingroup type_traits
+ */
+template <typename ...invocable_ts>
+struct multi_invocable : invocable_ts...
+{
+    //!\brief Inherit the function call operators.
+    using invocable_ts::operator()...;
+};
+
+//!\brief Deduction guides for seqan3::detail::multi_invocable.
+template <typename ...invocable_ts>
+multi_invocable(invocable_ts...) -> multi_invocable<invocable_ts...>;
+
+} // namespace seqan3::detail
diff --git a/include/seqan3/utility/type_list/type_list.hpp b/include/seqan3/utility/type_list/type_list.hpp
index 861a436fdd..e2aef7db31 100644
--- a/include/seqan3/utility/type_list/type_list.hpp
+++ b/include/seqan3/utility/type_list/type_list.hpp
@@ -14,7 +14,7 @@
 
 #include <meta/meta.hpp>
 
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3
 {
diff --git a/include/seqan3/utility/type_traits/all.hpp b/include/seqan3/utility/type_traits/all.hpp
new file mode 100644
index 0000000000..9076519ed2
--- /dev/null
+++ b/include/seqan3/utility/type_traits/all.hpp
@@ -0,0 +1,25 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides various type traits.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+/*!\defgroup type_traits Type Traits
+ * \brief Provides various type traits and their shortcuts.
+ * \ingroup utility
+ */
+
+#pragma once
+
+#include <seqan3/utility/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/concept.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
+#include <seqan3/utility/type_traits/function_traits.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
+#include <seqan3/utility/type_traits/pre.hpp>
diff --git a/include/seqan3/utility/type_traits/basic.hpp b/include/seqan3/utility/type_traits/basic.hpp
new file mode 100644
index 0000000000..ae425b2efe
--- /dev/null
+++ b/include/seqan3/utility/type_traits/basic.hpp
@@ -0,0 +1,168 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides various type traits on generic types.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <tuple>
+#include <seqan3/std/type_traits>
+
+#include <seqan3/core/platform.hpp>
+
+// ----------------------------------------------------------------------------
+// is_constexpr
+// ----------------------------------------------------------------------------
+
+/*!\brief Returns true if the expression passed to this macro can be evaluated at compile time, false otherwise.
+ * \ingroup type_traits
+ * \returns true or false.
+ */
+#define SEQAN3_IS_CONSTEXPR(...) std::integral_constant<bool, __builtin_constant_p((__VA_ARGS__, 0))>::value
+
+namespace seqan3
+{
+
+/*!\addtogroup type_traits
+ * \{
+ */
+
+// ----------------------------------------------------------------------------
+// remove_cvref_t
+// ----------------------------------------------------------------------------
+
+/*!\brief Return the input type with `const`, `volatile` and references removed (type trait).
+ * \tparam t The type to operate on.
+ */
+template <typename t>
+using remove_cvref_t SEQAN3_DEPRECATED_310 = std::remove_cv_t<std::remove_reference_t<t>>;
+
+// ----------------------------------------------------------------------------
+// remove_rvalue_reference
+// ----------------------------------------------------------------------------
+
+/*!\brief Return the input type with `&&` removed, but lvalue references preserved.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type to operate on.
+ * \see seqan3::remove_rvalue_reference_t
+ */
+template <typename t>
+struct remove_rvalue_reference
+{
+    //!\brief The return type is the input type with any `&&` stripped.
+    using type = std::conditional_t<std::is_rvalue_reference_v<t>, std::remove_reference_t<t>, t>;
+};
+
+/*!\brief Return the input type with `&&` removed, but lvalue references preserved (transformation_trait shortcut).
+ * \tparam t The type to operate on.
+ * \see seqan3::remove_rvalue_reference
+ */
+template <typename t>
+using remove_rvalue_reference_t = typename remove_rvalue_reference<t>::type;
+
+// ----------------------------------------------------------------------------
+// is_constexpr_default_constructible
+// ----------------------------------------------------------------------------
+
+/*!\brief Whether a type std::is_default_constructible in `constexpr`-context.
+ * \implements seqan3::unary_type_trait
+ * \tparam t The type to operate on.
+ */
+template <typename t>
+struct is_constexpr_default_constructible : std::false_type
+{};
+
+/*!\brief Whether a type std::is_default_constructible in `constexpr`-context (unary_type_trait specialisation).
+ * \tparam t A type that std::is_default_constructible.
+ * \see seqan3::is_constexpr_default_constructible
+ */
+template <typename t>
+//!\cond
+    requires std::is_default_constructible_v<t>
+//!\endcond
+struct is_constexpr_default_constructible<t> : std::integral_constant<bool, SEQAN3_IS_CONSTEXPR(t{})>
+{};
+
+/*!\brief Whether a type std::is_default_constructible in `constexpr`-context (unary_type_trait shortcut).
+ * \tparam t The type to operate on.
+ * \relates seqan3::is_constexpr_default_constructible
+ */
+template <typename t>
+inline constexpr bool is_constexpr_default_constructible_v = is_constexpr_default_constructible<t>::value;
+
+//!\}
+} // namespace seqan3
+
+namespace seqan3::detail
+{
+
+/*!\addtogroup type_traits
+ * \{
+ */
+
+// ----------------------------------------------------------------------------
+// deferred_type
+// ----------------------------------------------------------------------------
+
+/*!\brief Return the type identity; further arguments are ignored, but can make this type dependent if they are.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type to operate on.
+ * \tparam dependent_ts Any provided types are ignored.
+ * \see seqan3::detail::deferred_type_t
+ */
+template <typename t, typename ...dependent_ts>
+struct deferred_type
+{
+    //!\brief The type identity.
+    using type = t;
+};
+
+/*!\brief Return the type identity; further arguments are ignored, but can make this type dependent if they are
+ *        (transformation_trait shortcut).
+ * \tparam t The type to operate on.
+ * \tparam dependent_ts Any provided types are ignored.
+ * \see seqan3::detail::deferred_type
+ */
+template <typename t, typename ...dependent_ts>
+using deferred_type_t = typename deferred_type<t, dependent_ts...>::type;
+
+// ----------------------------------------------------------------------------
+// ignore_t
+// ----------------------------------------------------------------------------
+
+//!\brief Return the type of std::ignore with `const`, `volatile` and references removed (type trait).
+using ignore_t = std::remove_cvref_t<decltype(std::ignore)>;
+
+/*!\brief Return whether the input type with `const`, `volatile` and references removed is std::ignore's type.
+ * (type trait).
+ * \tparam t The type to operate on.
+ */
+template <typename t>
+constexpr bool decays_to_ignore_v = std::is_same_v<std::remove_cvref_t<t>, ignore_t>;
+
+//!\}
+
+} // namespace seqan3::detail
+
+// ----------------------------------------------------------------------------
+// SEQAN3_IS_SAME
+// ----------------------------------------------------------------------------
+
+/*!\brief A macro that behaves like std::is_same_v, except that it doesn't need to instantiate the template on GCC and
+ *        Clang.
+ * \ingroup type_traits
+ */
+#if defined(__clang__)
+#   define SEQAN3_IS_SAME(...)              __is_same(__VA_ARGS__)
+#elif defined(__GNUC__)
+#   define SEQAN3_IS_SAME(...)              __is_same_as(__VA_ARGS__)
+#else
+#   define SEQAN3_IS_SAME(...)              std::is_same_v<__VA_ARGS__>
+#endif
diff --git a/include/seqan3/utility/type_traits/concept.hpp b/include/seqan3/utility/type_traits/concept.hpp
new file mode 100644
index 0000000000..a39a4a8b8a
--- /dev/null
+++ b/include/seqan3/utility/type_traits/concept.hpp
@@ -0,0 +1,44 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides the concepts seqan3::transformation_trait and seqan3::unary_type_trait.
+ * \author Svenja Mehringer <svenja.mehringer AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <type_traits>
+
+#include <seqan3/core/platform.hpp>
+
+namespace seqan3
+{
+
+/*!\interface seqan3::transformation_trait
+ * \ingroup type_traits
+ * \brief Concept for a transformation trait.
+ *
+ * An object is a transformation trait if it exposes a member type called `type`.
+ */
+//!\cond
+template <typename t>
+SEQAN3_CONCEPT transformation_trait = requires { typename t::type; };
+//!\endcond
+
+/*!\interface seqan3::unary_type_trait
+ * \ingroup type_traits
+ * \brief Concept for a unary traits type.
+ *
+ * An object is a unary traits type if it is derived from std::integral_constant.
+ */
+//!\cond
+template <typename t>
+SEQAN3_CONCEPT unary_type_trait = std::is_base_of_v<std::integral_constant<typename t::value_type, t::value>, t>;
+//!\endcond
+
+} // namespace seqan3
diff --git a/include/seqan3/utility/type_traits/detail/transformation_trait_or.hpp b/include/seqan3/utility/type_traits/detail/transformation_trait_or.hpp
new file mode 100644
index 0000000000..9774bdd491
--- /dev/null
+++ b/include/seqan3/utility/type_traits/detail/transformation_trait_or.hpp
@@ -0,0 +1,53 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \author Marcel Ehrhardt <marcel.ehrhardt AT fu-berlin.de>
+ * \brief Provides seqan3::detail::transformation_trait_or.
+ */
+
+#pragma once
+
+#include <seqan3/std/type_traits>
+
+#include <seqan3/utility/type_traits/concept.hpp>
+
+namespace seqan3::detail
+{
+
+/*!\brief This gives a fallback type if *type_t::type* is not defined.
+ * \implements seqan3::transformation_trait
+ * \ingroup type_traits
+ * \tparam type_t    The type to use if *type_t::type* is defined.
+ * \tparam default_t The type to use otherwise.
+ * \see seqan3::detail::transformation_trait_or_t
+ *
+ * \details
+ *
+ * Gives *type_t* back if *T::type* is a member type, otherwise *struct{using type = default_t}*.
+ *
+ * \include test/snippet/utility/type_traits/transformation_trait_or.cpp
+ *
+ * \attention This might get removed if one of our used libraries offers the same
+ * functionality.
+ *
+ * ###Helper types
+ *   seqan3::detail::transformation_trait_or_t as a shorthand for *seqan3::detail::transformation_trait_or::type*
+ */
+template <typename type_t, typename default_t>
+using transformation_trait_or = std::conditional_t<transformation_trait<type_t>,    // check if type_t::type exists
+                                                   type_t,                          // if yes, return type_t
+                                                   std::type_identity<default_t>>;  // else return default_t as trait
+
+/*!\brief Helper type of seqan3::detail::transformation_trait_or (transformation_trait shortcut).
+ * \ingroup type_traits
+ * \see seqan3::detail::transformation_trait_or
+ */
+template <typename type_t, typename default_t>
+using transformation_trait_or_t = typename transformation_trait_or<type_t, default_t>::type;
+
+} // namespace seqan3::detail
diff --git a/include/seqan3/utility/type_traits/function_traits.hpp b/include/seqan3/utility/type_traits/function_traits.hpp
new file mode 100644
index 0000000000..2dba3e472b
--- /dev/null
+++ b/include/seqan3/utility/type_traits/function_traits.hpp
@@ -0,0 +1,69 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides various type traits for use on functions.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <seqan3/utility/type_pack/traits.hpp>
+
+namespace seqan3
+{
+
+//!\cond
+template <typename function_t>
+struct function_traits;
+//!\endcond
+
+/*!\brief A traits class to provide a uniform interface to the properties of a function type.
+ * \ingroup type_traits
+ * \tparam return_t The return type of the function.
+ * \tparam args_t A template parameter pack over the argument types of the function.
+ *
+ * \details
+ *
+ * seqan3::function_traits is the type trait class that provides a uniform interface to the properties of
+ * a std::function type, a lambda type, a function type or a function pointer type.
+ * This makes it possible to access the return type and the argument types of the stored target function.
+ * The function types must be complete, i.e. all argument types and the return type must be known, otherwise
+ * this traits class is incomplete.
+ *
+ * ### Example
+ *
+ * \include snippet/utility/type_traits/function_traits.cpp
+ */
+template <typename return_t, typename ...args_t>
+struct function_traits<std::function<return_t(args_t...)>>
+{
+    //!\brief The number of arguments passed to the std::function target.
+    static constexpr size_t argument_count = sizeof...(args_t);
+
+    //!\brief The return type of the function target.
+    using result_type = return_t;
+
+    /*!\brief The argument type at the given `index`.
+     * \tparam index The position of the argument to get the type for; must be smaller than `argument_count`.
+     */
+    template <size_t index>
+    //!\cond
+        requires (index < argument_count)
+    //!\endcond
+    using argument_type_at = pack_traits::at<index, args_t...>;
+};
+
+//!\cond
+// Overload for all function types.
+template <typename function_t>
+    requires requires (function_t fn) { {std::function{fn}}; }
+struct function_traits<function_t> : function_traits<decltype(std::function{std::declval<function_t>()})>
+{};
+//!\endcond
+
+} // namespace seqan3
diff --git a/include/seqan3/utility/type_traits/lazy_conditional.hpp b/include/seqan3/utility/type_traits/lazy_conditional.hpp
new file mode 100644
index 0000000000..4ee33d0f21
--- /dev/null
+++ b/include/seqan3/utility/type_traits/lazy_conditional.hpp
@@ -0,0 +1,161 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides lazy template instantiation traits.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <seqan3/std/type_traits>
+
+#include <seqan3/core/platform.hpp>
+
+namespace seqan3::detail
+{
+
+/*!\addtogroup type_traits
+ * \{
+ */
+
+// ----------------------------------------------------------------------------
+// lazy
+// ----------------------------------------------------------------------------
+
+/*!\brief An empty type whose only purpose is to hold an uninstantiated template plus its arguments.
+ * \tparam template_t The uninstantiated template.
+ * \tparam spec_t     The arguments to template_t.
+ */
+template <template <typename ...> typename template_t, typename ...spec_t>
+struct lazy
+{};
+
+// ----------------------------------------------------------------------------
+// instantiate
+// ----------------------------------------------------------------------------
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types. Base template is the identity transformation.
+ * \tparam t The type to operate on.
+ * \implements seqan3::transformation_trait
+ */
+template <typename t>
+struct instantiate : std::type_identity<t>
+{};
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types.
+ * \tparam template_t The uninstantiated template.
+ * \tparam spec_t     The arguments to template_t.
+ * \implements seqan3::transformation_trait
+ */
+template <template <typename ...> typename template_t, typename ...spec_t>
+struct instantiate<lazy<template_t, spec_t...>>
+{
+    //!\brief Return type of the trait [instantiates the template arguments].
+    using type = template_t<spec_t...>;
+};
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types. Transformation trait shortcut.
+ * \tparam t The type to operate on.
+ * \relates seqan3::detail::instantiate
+ */
+template <typename t>
+//!\cond
+    requires requires { typename instantiate<t>::type; }
+//!\endcond
+using instantiate_t = typename instantiate<t>::type;
+
+// ----------------------------------------------------------------------------
+// instantiate_if
+// ----------------------------------------------------------------------------
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types given a boolean condition.
+ *        Base template is std::false_type.
+ * \tparam t The type to operate on.
+ * \implements seqan3::transformation_trait
+ */
+template <typename t, bool condition>
+struct instantiate_if : std::false_type
+{};
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types given a boolean condition.
+ *        If condition is true and parameter is not lazy, the type identity.
+ * \tparam t The type to operate on.
+ * \implements seqan3::transformation_trait
+ */
+template <typename t>
+struct instantiate_if<t, true> : std::type_identity<t>
+{};
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types given a boolean condition.
+ *        If condition is true and parameter is lazy, the instantiated type.
+ * \tparam template_t The uninstantiated template.
+ * \tparam spec_t     The arguments to template_t.
+ * \implements seqan3::transformation_trait
+ */
+template <template <typename ...> typename template_t, typename ...spec_t>
+struct instantiate_if<lazy<template_t, spec_t...>, true>
+{
+    //!\brief Return type of the trait [instantiates the template arguments].
+    using type = template_t<spec_t...>;
+};
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types, conditionally. Transformation trait shortcut.
+ * \tparam t The type to operate on.
+ * \relates seqan3::detail::instantiate_if
+ */
+template <typename t, bool condition>
+//!\cond
+    requires requires { typename instantiate_if<t, condition>::type; }
+//!\endcond
+using instantiate_if_t = typename instantiate_if<t, condition>::type;
+
+/*!\brief A transformation trait that instantiates seqan3::lazy types, conditionally. Type trait shortcut.
+ * \tparam t The type to operate on.
+ * \relates seqan3::detail::instantiate_if
+ */
+template <typename t, bool condition>
+//!\cond
+    requires requires { instantiate_if_t<t, condition>::value; }
+//!\endcond
+inline constexpr auto instantiate_if_v = instantiate_if_t<t, condition>::value;
+
+// ----------------------------------------------------------------------------
+// lazy_conditional
+// ----------------------------------------------------------------------------
+
+/*!\brief Behaves like std::conditional, but instantiates types wrapped in seqan3::lazy.
+ * \tparam decision   Whether to resolve to the first type or the second.
+ * \tparam on_true_t  The return type in case `decision` is true.
+ * \tparam on_false_t The return type in case `decision` is false.
+ * \implements seqan3::transformation_trait
+ *
+ * \details
+ *
+ * ### Example
+ *
+ * \include test/snippet/utility/type_traits/lazy_conditional.cpp
+ */
+template <bool decision, typename on_true_t, typename on_false_t>
+struct lazy_conditional : instantiate<std::conditional_t<decision, on_true_t, on_false_t>>
+{};
+
+/*!\brief Behaves like std::conditional_t, but instantiates types wrapped in seqan3::lazy. Transformation trait shortcut.
+ * \tparam decision   Whether to resolve to the first type or the second.
+ * \tparam on_true_t  The return type in case `decision` is true.
+ * \tparam on_false_t The return type in case `decision` is false.
+ * \relates seqan3::detail::lazy_conditional
+ */
+template <bool decision, typename on_true_t, typename on_false_t>
+//!\cond
+    requires requires { typename instantiate_t<std::conditional_t<decision, on_true_t, on_false_t>>; }
+//!\endcond
+using lazy_conditional_t = instantiate_t<std::conditional_t<decision, on_true_t, on_false_t>>;
+
+//!\}
+
+} // namespace seqan3::detail
diff --git a/include/seqan3/utility/type_traits/pre.hpp b/include/seqan3/utility/type_traits/pre.hpp
new file mode 100644
index 0000000000..7b18cd93e8
--- /dev/null
+++ b/include/seqan3/utility/type_traits/pre.hpp
@@ -0,0 +1,323 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+/*!\file
+ * \brief Provides various transformation trait base templates and shortcuts.
+ * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
+ */
+
+#pragma once
+
+#include <seqan3/core/platform.hpp>
+
+namespace seqan3
+{
+
+/*!\addtogroup type_traits
+ * \{
+ */
+
+// ----------------------------------------------------------------------------
+// value_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+//!\brief This is helper structure to deprecate seqan3::value_type and will be removed before SeqAn 3.1.
+template <typename t>
+struct value_type;
+
+//!\brief This is helper structure to deprecate seqan3::value_type_t and will be removed before SeqAn 3.1.
+template <typename t>
+using value_type_t = typename value_type<t>::type;
+} // namespace seqan3::detail
+#endif
+
+/*!\brief Exposes the `value_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query.
+ * \see seqan3::value_type_t
+ *
+ * \details
+ *
+ * This is a pure declaration, you need to create a *definition* for concrete types
+ * or specialized or constrained templates.
+ *
+ * There is a shortcut for this transformation trait: seqan3::value_type_t
+ *
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_value_t instead or
+ *             if `t` models std::input_iterator use std::iter_value_t instead.
+ */
+template <typename t>
+struct SEQAN3_DEPRECATED_310 value_type : detail::value_type<t>
+{};
+
+/*!\brief Shortcut for seqan3::value_type (transformation_trait shortcut).
+ * \tparam t The type you wish to query.
+ * \see seqan3::value_type
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_value_t instead or
+ *             if `t` models std::input_iterator use std::iter_value_t instead.
+ */
+template <typename t>
+using value_type_t SEQAN3_DEPRECATED_310 = typename detail::value_type_t<t>;
+
+// see specialisation for iterators in core/type_traits/iterator.hpp
+// see specialisation for ranges in core/type_traits/range.hpp
+
+// ----------------------------------------------------------------------------
+// reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+//!\brief This is helper structure to deprecate seqan3::reference and will be removed before SeqAn 3.1.
+template <typename t>
+struct reference;
+
+//!\brief This is helper structure to deprecate seqan3::reference_t and will be removed before SeqAn 3.1.
+template <typename t>
+using reference_t = typename reference<t>::type;
+} // namespace seqan3::detail
+#endif
+
+/*!\brief Exposes the `reference` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query.
+ * \see seqan3::reference_t
+ *
+ * \details
+ *
+ * This is a pure declaration, you need to create a *definition* for concrete types
+ * or specialized or constrained templates.
+ *
+ * There is a shortcut for this transformation trait: seqan3::reference_t
+ *
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t instead or
+ *             if `t` models std::input_iterator use std::iter_reference_t instead.
+ */
+template <typename t>
+struct SEQAN3_DEPRECATED_310 reference : detail::reference<t>
+{};
+
+/*!\brief Shortcut for seqan3::reference (transformation_trait shortcut).
+ * \tparam t The type you wish to query.
+ * \see seqan3::reference
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t instead or
+ *             if `t` models std::input_iterator use std::iter_reference_t instead.
+ */
+template <typename t>
+using reference_t SEQAN3_DEPRECATED_310 = typename detail::reference_t<t>;
+
+// see specialisation for iterators in core/type_traits/iterator.hpp
+// see specialisation for ranges in core/type_traits/range.hpp
+
+// ----------------------------------------------------------------------------
+// rvalue_reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+//!\brief This is helper structure to deprecate seqan3::rvalue_reference and will be removed before SeqAn 3.1.
+template <typename t>
+struct rvalue_reference;
+
+//!\brief This is helper structure to deprecate seqan3::rvalue_reference_t and will be removed before SeqAn 3.1.
+template <typename t>
+using rvalue_reference_t = typename rvalue_reference<t>::type;
+} // namespace seqan3::detail
+#endif
+
+/*!\brief Exposes the `rvalue_reference` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query.
+ * \see seqan3::rvalue_reference_t
+ *
+ * \details
+ *
+ * This is a pure declaration, you need to create a *definition* for concrete types
+ * or specialized or constrained templates.
+ *
+ * There is a shortcut for this transformation trait: seqan3::rvalue_reference_t
+ *
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_rvalue_reference_t instead or
+ *             if `t` models std::input_iterator use std::iter_rvalue_reference_t instead.
+ */
+template <typename t>
+struct SEQAN3_DEPRECATED_310 rvalue_reference : detail::rvalue_reference<t>
+{};
+
+/*!\brief Shortcut for seqan3::rvalue_reference (transformation_trait shortcut).
+ * \tparam t The type you wish to query.
+ * \see seqan3::rvalue_reference
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_rvalue_reference_t instead or
+ *             if `t` models std::input_iterator use std::iter_rvalue_reference_t instead.
+ */
+template <typename t>
+using rvalue_reference_t SEQAN3_DEPRECATED_310 = typename detail::rvalue_reference_t<t>;
+
+// see specialisation for iterators in core/type_traits/iterator.hpp
+// see specialisation for ranges in core/type_traits/range.hpp
+
+// ----------------------------------------------------------------------------
+// const_reference
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+//!\brief This is helper structure to deprecate seqan3::const_reference and will be removed before SeqAn 3.1.
+template <typename t>
+struct const_reference;
+
+//!\brief This is helper structure to deprecate seqan3::const_reference_t and will be removed before SeqAn 3.1.
+template <typename t>
+using const_reference_t = typename const_reference<t>::type;
+} // namespace seqan3::detail
+#endif
+
+/*!\brief Exposes the `const_reference` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query.
+ * \see seqan3::const_reference_t
+ *
+ * \details
+ *
+ * This is a pure declaration, you need to create a *definition* for concrete types
+ * or specialized or constrained templates.
+ *
+ * There is a shortcut for this transformation trait: seqan3::const_reference_t
+ *
+ * \attention This transformation trait is not overloaded for iterators by default, but it is for ranges.
+ *
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t<t const> instead or
+ *             if `t` models std::input_iterator use std::iter_reference_t<t const> instead.
+ */
+template <typename t>
+struct SEQAN3_DEPRECATED_310 const_reference : detail::const_reference<t>
+{};
+
+
+/*!\brief Shortcut for seqan3::const_reference (transformation_trait shortcut).
+ * \tparam t The type you wish to query.
+ * \see seqan3::const_reference
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_reference_t<t const> instead or
+ *             if `t` models std::input_iterator use std::iter_reference_t<t const> instead.
+ */
+template <typename t>
+using const_reference_t SEQAN3_DEPRECATED_310 = typename detail::const_reference_t<t>;
+
+
+// no specialisation for iterators
+// see specialisation for ranges in core/type_traits/range.hpp
+
+// ----------------------------------------------------------------------------
+// difference_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+//!\brief This is helper structure to deprecate seqan3::difference_type and will be removed before SeqAn 3.1.
+template <typename t>
+struct difference_type;
+
+//!\brief This is helper structure to deprecate seqan3::difference_type_t and will be removed before SeqAn 3.1.
+template <typename t>
+using difference_type_t = typename difference_type<t>::type;
+} // namespace seqan3::detail
+#endif
+
+/*!\brief Exposes the `difference_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query.
+ * \see seqan3::difference_type_t
+ *
+ * \details
+ *
+ * This is a pure declaration, you need to create a *definition* for concrete types
+ * or specialized or constrained templates.
+ *
+ * There is a shortcut for this transformation trait: seqan3::difference_type_t
+ *
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_difference_t instead or
+ *             if `t` models std::input_iterator use std::iter_difference_t instead.
+ */
+template <typename t>
+struct SEQAN3_DEPRECATED_310 difference_type : detail::difference_type<t>
+{};
+
+
+/*!\brief Shortcut for seqan3::difference_type (transformation_trait shortcut).
+ * \tparam t The type you wish to query.
+ * \see seqan3::difference_type
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_difference_t instead or
+ *             if `t` models std::input_iterator use std::iter_difference_t instead.
+ */
+template <typename t>
+using difference_type_t SEQAN3_DEPRECATED_310 = typename detail::difference_type_t<t>;
+
+
+// see specialisation for iterators in core/type_traits/iterator.hpp
+// see specialisation for ranges in core/type_traits/range.hpp
+
+// ----------------------------------------------------------------------------
+// size_type
+// ----------------------------------------------------------------------------
+
+#ifdef SEQAN3_DEPRECATED_310
+namespace detail
+{
+//!\brief This is helper structure to deprecate seqan3::size_type and will be removed before SeqAn 3.1.
+template <typename t>
+struct size_type;
+
+//!\brief This is helper structure to deprecate seqan3::size_type_t and will be removed before SeqAn 3.1.
+template <typename t>
+using size_type_t = typename size_type<t>::type;
+} // namespace seqan3::detail
+#endif
+
+/*!\brief Exposes the `size_type` of another type.
+ * \implements seqan3::transformation_trait
+ * \tparam t The type you wish to query.
+ * \see seqan3::size_type_t
+ *
+ * \details
+ *
+ * This is a pure declaration, you need to create a *definition* for concrete types
+ * or specialized or constrained templates.
+ *
+ * There is a shortcut for this transformation trait: seqan3::size_type_t
+ *
+ * \deprecated If `t` models std::ranges::range use std::ranges::range_size_t instead.
+ *             If `t` models std::input_iterator there is no alternative. Unlike std::ranges::range_size_t, the Standard
+ *             has no std::iter_size_t.
+ *
+ */
+template <typename t>
+struct SEQAN3_DEPRECATED_310 size_type : detail::size_type<t>
+{};
+
+/*!\brief Shortcut for seqan3::size_type (transformation_trait shortcut).
+ * \tparam t The type you wish to query.
+ * \see seqan3::size_type
+ * \deprecated If `t` models std::ranges::range use std::ranges::size_type_t instead.
+ *             If `t` models std::input_iterator there is no alternative. Unlike std::ranges::range_size_t, the Standard
+ *             has no std::iter_size_t.
+ */
+template <typename t>
+using size_type_t SEQAN3_DEPRECATED_310 = typename detail::size_type_t<t>;
+
+// see specialisation for iterators in core/type_traits/iterator.hpp
+// see specialisation for ranges in core/type_traits/range.hpp
+
+//!\}
+
+} // namespace seqan3
diff --git a/test/include/seqan3/test/cereal.hpp b/test/include/seqan3/test/cereal.hpp
index b9d0f04611..752c7a6e28 100644
--- a/test/include/seqan3/test/cereal.hpp
+++ b/test/include/seqan3/test/cereal.hpp
@@ -18,8 +18,8 @@
 
 #include <seqan3/core/concept/cereal.hpp>
 #include <seqan3/core/platform.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/test/tmp_filename.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 #if SEQAN3_WITH_CEREAL
 #include <cereal/archives/binary.hpp>
diff --git a/test/include/seqan3/test/performance/naive_kmer_hash.hpp b/test/include/seqan3/test/performance/naive_kmer_hash.hpp
index f6fb8c78f0..6a2245a507 100644
--- a/test/include/seqan3/test/performance/naive_kmer_hash.hpp
+++ b/test/include/seqan3/test/performance/naive_kmer_hash.hpp
@@ -12,12 +12,13 @@
 
 #pragma once
 
+#include <seqan3/std/ranges>
+
 #include <range/v3/view/sliding.hpp>
 
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/detail.hpp>
-#include <seqan3/std/ranges>
 
 namespace seqan3::detail
 {
diff --git a/test/include/seqan3/test/performance/naive_minimiser_hash.hpp b/test/include/seqan3/test/performance/naive_minimiser_hash.hpp
index cc2d6ff33d..0770f80692 100644
--- a/test/include/seqan3/test/performance/naive_minimiser_hash.hpp
+++ b/test/include/seqan3/test/performance/naive_minimiser_hash.hpp
@@ -17,7 +17,7 @@
 #include <range/v3/view/sliding.hpp>
 
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/complement.hpp>
 #include <seqan3/range/views/detail.hpp>
 #include <seqan3/range/views/kmer_hash.hpp>
diff --git a/test/include/seqan3/test/performance/units.hpp b/test/include/seqan3/test/performance/units.hpp
index b6194ee0fe..da863bded4 100644
--- a/test/include/seqan3/test/performance/units.hpp
+++ b/test/include/seqan3/test/performance/units.hpp
@@ -14,11 +14,12 @@
 
 #include <benchmark/benchmark.h>
 
+#include <seqan3/std/ranges>
+
 #include <seqan3/alignment/configuration/align_config_band.hpp>
 #include <seqan3/core/concept/tuple.hpp>
-#include <seqan3/core/type_traits/range.hpp>
 #include <seqan3/core/platform.hpp>
-#include <seqan3/std/ranges>
+#include <seqan3/core/range/type_traits.hpp>
 
 namespace seqan3::test
 {
diff --git a/test/performance/search/index_construction_benchmark.cpp b/test/performance/search/index_construction_benchmark.cpp
index ec30dfcd96..71d71188df 100644
--- a/test/performance/search/index_construction_benchmark.cpp
+++ b/test/performance/search/index_construction_benchmark.cpp
@@ -9,12 +9,12 @@
 
 #include <seqan3/alphabet/aminoacid/aa27.hpp>
 #include <seqan3/alphabet/nucleotide/dna4.hpp>
-#include <seqan3/core/type_traits/lazy.hpp>
 #include <seqan3/range/views/persist.hpp>
 #include <seqan3/range/views/rank_to.hpp>
 #include <seqan3/search/fm_index/all.hpp>
 #include <seqan3/test/performance/sequence_generator.hpp>
 #include <seqan3/test/seqan2.hpp>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 #if SEQAN3_HAS_SEQAN2
 #include <seqan/index.h>
diff --git a/test/snippet/core/type_traits/deferred_crtp_base.cpp b/test/snippet/core/detail/deferred_crtp_base.cpp
similarity index 97%
rename from test/snippet/core/type_traits/deferred_crtp_base.cpp
rename to test/snippet/core/detail/deferred_crtp_base.cpp
index 888e184341..04ced35a6f 100644
--- a/test/snippet/core/type_traits/deferred_crtp_base.cpp
+++ b/test/snippet/core/detail/deferred_crtp_base.cpp
@@ -1,7 +1,7 @@
 #include <string>
 #include <type_traits>
 
-#include <seqan3/core/type_traits/deferred_crtp_base.hpp>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
 
 // Defines a crtp_base class with an additional value type.
 template <typename derived_t, int value>
diff --git a/test/snippet/core/type_traits/is_class_template_declarable_with.cpp b/test/snippet/core/detail/is_class_template_declarable_with.cpp
similarity index 96%
rename from test/snippet/core/type_traits/is_class_template_declarable_with.cpp
rename to test/snippet/core/detail/is_class_template_declarable_with.cpp
index 862056e7f9..e8c4c44b98 100644
--- a/test/snippet/core/type_traits/is_class_template_declarable_with.cpp
+++ b/test/snippet/core/detail/is_class_template_declarable_with.cpp
@@ -1,7 +1,7 @@
 #include <type_traits>
 
-#include <seqan3/core/type_traits/lazy.hpp>
 #include <seqan3/core/debug_stream.hpp>
+#include <seqan3/core/detail/is_class_template_declarable.hpp>
 
 template <typename t>
     requires std::is_integral_v<t>
diff --git a/test/snippet/core/type_traits/template_inspection_usage.cpp b/test/snippet/core/detail/template_inspection_usage.cpp
similarity index 80%
rename from test/snippet/core/type_traits/template_inspection_usage.cpp
rename to test/snippet/core/detail/template_inspection_usage.cpp
index 817450a43f..cecafcdf52 100644
--- a/test/snippet/core/type_traits/template_inspection_usage.cpp
+++ b/test/snippet/core/detail/template_inspection_usage.cpp
@@ -1,4 +1,4 @@
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/utility/type_list/type_list.hpp>
 
 int main()
diff --git a/test/snippet/core/type_traits/template_inspection_usage_2.cpp b/test/snippet/core/detail/template_inspection_usage_2.cpp
similarity index 66%
rename from test/snippet/core/type_traits/template_inspection_usage_2.cpp
rename to test/snippet/core/detail/template_inspection_usage_2.cpp
index 5577eaa9b3..785cdcf7fa 100644
--- a/test/snippet/core/type_traits/template_inspection_usage_2.cpp
+++ b/test/snippet/core/detail/template_inspection_usage_2.cpp
@@ -1,7 +1,6 @@
 #include <vector>
 
-#include <seqan3/core/type_traits/template_inspection.hpp>
-#include <seqan3/utility/type_list/type_list.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 int main()
 {
diff --git a/test/snippet/core/type_traits/range.cpp b/test/snippet/core/type_traits/range.cpp
deleted file mode 100644
index e2cede307d..0000000000
--- a/test/snippet/core/type_traits/range.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <seqan3/core/type_traits/range.hpp>
-
-int main()
-{
-    // these evaluate to true:
-    static_assert(seqan3::range_compatible<std::string,              std::vector<char>>);
-    static_assert(seqan3::range_compatible<std::vector<std::string>, std::vector<std::vector<char>>>);
-}
diff --git a/test/snippet/utility/type_list/list_traits_transform.cpp b/test/snippet/utility/type_list/list_traits_transform.cpp
index fff462ba66..db7b8c9fc5 100644
--- a/test/snippet/utility/type_list/list_traits_transform.cpp
+++ b/test/snippet/utility/type_list/list_traits_transform.cpp
@@ -1,8 +1,8 @@
 #include <list>
 #include <vector>
 
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/utility/type_list/traits.hpp>
-#include <seqan3/core/type_traits/range.hpp>
 
 int main()
 {
diff --git a/test/snippet/utility/type_pack/pack_traits_transform.cpp b/test/snippet/utility/type_pack/pack_traits_transform.cpp
index c72cc021b8..111bb49654 100644
--- a/test/snippet/utility/type_pack/pack_traits_transform.cpp
+++ b/test/snippet/utility/type_pack/pack_traits_transform.cpp
@@ -1,8 +1,8 @@
 #include <list>
 #include <vector>
 
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/utility/type_pack/traits.hpp>
-#include <seqan3/core/type_traits/range.hpp>
 
 int main()
 {
diff --git a/test/snippet/core/type_traits/function_traits.cpp b/test/snippet/utility/type_traits/function_traits.cpp
similarity index 85%
rename from test/snippet/core/type_traits/function_traits.cpp
rename to test/snippet/utility/type_traits/function_traits.cpp
index 5701649752..b7c2e10e23 100644
--- a/test/snippet/core/type_traits/function_traits.cpp
+++ b/test/snippet/utility/type_traits/function_traits.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <functional>
 #include <string>
 
-#include <seqan3/core/type_traits/function.hpp>
-#include <seqan3/std/concepts>
+#include <seqan3/utility/type_traits/function_traits.hpp>
 
 std::function my_caller = [] (size_t position, std::string & sequence)
 {
diff --git a/test/snippet/core/type_traits/lazy.cpp b/test/snippet/utility/type_traits/lazy_conditional.cpp
similarity index 71%
rename from test/snippet/core/type_traits/lazy.cpp
rename to test/snippet/utility/type_traits/lazy_conditional.cpp
index 7b8d6ce2f5..5b77b9fdf2 100644
--- a/test/snippet/core/type_traits/lazy.cpp
+++ b/test/snippet/utility/type_traits/lazy_conditional.cpp
@@ -1,8 +1,9 @@
-#include <vector>                               // std::vector
-#include <forward_list>                         // std::forward_list
-#include <seqan3/core/type_traits/lazy.hpp>     // seqan3::lazy and seqan3::lazy_conditional_t
-#include <seqan3/core/type_traits/range.hpp>    // seqan3::size_type_t
-#include <seqan3/std/ranges>                    // std::ranges::input_range
+#include <forward_list>                                    // std::forward_list
+#include <seqan3/std/ranges>                               // std::ranges::input_range
+#include <vector>                                          // std::vector
+
+#include <seqan3/core/range/type_traits.hpp>               // seqan3::size_type_t
+#include <seqan3/utility/type_traits/lazy_conditional.hpp> // seqan3::lazy_conditional_t
 
 template <std::ranges::input_range rng_t>
 void foobar(rng_t && range)
diff --git a/test/snippet/core/type_traits/transformation_trait_or.cpp b/test/snippet/utility/type_traits/transformation_trait_or.cpp
similarity index 84%
rename from test/snippet/core/type_traits/transformation_trait_or.cpp
rename to test/snippet/utility/type_traits/transformation_trait_or.cpp
index d2a3c24917..ea88504229 100644
--- a/test/snippet/core/type_traits/transformation_trait_or.cpp
+++ b/test/snippet/utility/type_traits/transformation_trait_or.cpp
@@ -1,4 +1,4 @@
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 template <typename T>
 struct A;
diff --git a/test/unit/alignment/configuration/align_config_output_test.cpp b/test/unit/alignment/configuration/align_config_output_test.cpp
index e122761ad7..84a03ee8e5 100644
--- a/test/unit/alignment/configuration/align_config_output_test.cpp
+++ b/test/unit/alignment/configuration/align_config_output_test.cpp
@@ -11,7 +11,7 @@
 
 #include <seqan3/alignment/configuration/align_config_output.hpp>
 #include <seqan3/core/algorithm/configuration.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 #include "../../core/algorithm/pipeable_config_element_test_template.hpp"
 
diff --git a/test/unit/alignment/configuration/align_config_score_type_test.cpp b/test/unit/alignment/configuration/align_config_score_type_test.cpp
index cf0be4d454..9237694a6e 100644
--- a/test/unit/alignment/configuration/align_config_score_type_test.cpp
+++ b/test/unit/alignment/configuration/align_config_score_type_test.cpp
@@ -11,7 +11,7 @@
 
 #include <seqan3/alignment/configuration/align_config_score_type.hpp>
 #include <seqan3/core/algorithm/configuration.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 #include "../../core/algorithm/pipeable_config_element_test_template.hpp"
 
diff --git a/test/unit/alignment/pairwise/alignment_result_test.cpp b/test/unit/alignment/pairwise/alignment_result_test.cpp
index 540fad6942..9ad9947a35 100644
--- a/test/unit/alignment/pairwise/alignment_result_test.cpp
+++ b/test/unit/alignment/pairwise/alignment_result_test.cpp
@@ -17,7 +17,7 @@
 #include <seqan3/alphabet/gap/gapped.hpp>
 #include <seqan3/alphabet/nucleotide/dna4.hpp>
 #include <seqan3/alphabet/nucleotide/rna5.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/range/views/persist.hpp>
 #include <seqan3/range/views/to_char.hpp>
 #include <seqan3/range/views/to.hpp>
diff --git a/test/unit/alignment/pairwise/policy/affine_gap_init_policy_test.cpp b/test/unit/alignment/pairwise/policy/affine_gap_init_policy_test.cpp
index 7c7cc76730..b29b242662 100644
--- a/test/unit/alignment/pairwise/policy/affine_gap_init_policy_test.cpp
+++ b/test/unit/alignment/pairwise/policy/affine_gap_init_policy_test.cpp
@@ -7,6 +7,7 @@
 
 #include <gtest/gtest.h>
 
+#include <seqan3/std/ranges>
 #include <type_traits>
 
 #include <seqan3/alignment/pairwise/detail/alignment_algorithm_state.hpp>
@@ -16,8 +17,7 @@
 #include <seqan3/alignment/matrix/detail/alignment_trace_matrix_full.hpp>
 #include <seqan3/alignment/pairwise/policy/affine_gap_init_policy.hpp>
 #include <seqan3/alphabet/nucleotide/dna4.hpp>
-#include <seqan3/core/type_traits/basic.hpp>
-#include <seqan3/std/ranges>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 using seqan3::operator""_dna4;
 
diff --git a/test/unit/core/detail/CMakeLists.txt b/test/unit/core/detail/CMakeLists.txt
index 2ea266f9cf..9bb3f9e258 100644
--- a/test/unit/core/detail/CMakeLists.txt
+++ b/test/unit/core/detail/CMakeLists.txt
@@ -1,6 +1,9 @@
 seqan3_test(debug_stream_type_tuple_alignment_test.cpp)
+seqan3_test(deferred_crtp_base_test.cpp)
 seqan3_test(integer_traits_test.cpp)
+seqan3_test(iterator_traits_test.cpp)
 seqan3_test(pack_algorithm_test.cpp)
 seqan3_test(strong_type_debug_stream_test.cpp)
 seqan3_test(strong_type_test.cpp)
+seqan3_test(template_inspection_test.cpp)
 seqan3_test(type_name_as_string_test.cpp)
diff --git a/test/unit/core/type_traits/deferred_crtp_base_test.cpp b/test/unit/core/detail/deferred_crtp_base_test.cpp
similarity index 97%
rename from test/unit/core/type_traits/deferred_crtp_base_test.cpp
rename to test/unit/core/detail/deferred_crtp_base_test.cpp
index b43b5c1e01..049f1ed540 100644
--- a/test/unit/core/type_traits/deferred_crtp_base_test.cpp
+++ b/test/unit/core/detail/deferred_crtp_base_test.cpp
@@ -9,7 +9,7 @@
 
 #include <type_traits>
 
-#include <seqan3/core/type_traits/deferred_crtp_base.hpp>
+#include <seqan3/core/detail/deferred_crtp_base.hpp>
 
 // Defines a crtp_base class with an additional value type.
 template <typename derived_t, typename value_t = std::string>
diff --git a/test/unit/core/type_traits/type_traits_iterator_test.cpp b/test/unit/core/detail/iterator_traits_test.cpp
similarity index 99%
rename from test/unit/core/type_traits/type_traits_iterator_test.cpp
rename to test/unit/core/detail/iterator_traits_test.cpp
index eafdd6d14d..a804a94efd 100644
--- a/test/unit/core/type_traits/type_traits_iterator_test.cpp
+++ b/test/unit/core/detail/iterator_traits_test.cpp
@@ -14,7 +14,7 @@
 #include <seqan3/std/ranges>
 #include <vector>
 
-#include <seqan3/core/type_traits/iterator.hpp>
+#include <seqan3/core/detail/iterator_traits.hpp>
 
 template <typename iterator_t>
 SEQAN3_CONCEPT iterator_traits_has_iterator_category = requires()
diff --git a/test/unit/core/type_traits/template_inspection_test.cpp b/test/unit/core/detail/template_inspection_test.cpp
similarity index 98%
rename from test/unit/core/type_traits/template_inspection_test.cpp
rename to test/unit/core/detail/template_inspection_test.cpp
index 408e01aeb7..d138fd3e82 100644
--- a/test/unit/core/type_traits/template_inspection_test.cpp
+++ b/test/unit/core/detail/template_inspection_test.cpp
@@ -9,9 +9,9 @@
 
 #include <gtest/gtest.h>
 
-#include <seqan3/core/type_traits/concept.hpp>
-#include <seqan3/core/type_traits/template_inspection.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 #include <seqan3/utility/type_list/type_list.hpp>
+#include <seqan3/utility/type_traits/concept.hpp>
 
 template <std::integral t>
 struct constraint_bar
diff --git a/test/unit/core/my_tuple.hpp b/test/unit/core/my_tuple.hpp
index 9d7b6d85a8..976683a931 100644
--- a/test/unit/core/my_tuple.hpp
+++ b/test/unit/core/my_tuple.hpp
@@ -15,7 +15,7 @@
 #include <tuple>
 #include <utility>
 
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 namespace seqan3
 {
diff --git a/test/unit/core/range/CMakeLists.txt b/test/unit/core/range/CMakeLists.txt
new file mode 100644
index 0000000000..1cf8133438
--- /dev/null
+++ b/test/unit/core/range/CMakeLists.txt
@@ -0,0 +1 @@
+seqan3_test(range_iterator_test.cpp)
diff --git a/test/unit/core/type_traits/range_iterator_test.cpp b/test/unit/core/range/range_iterator_test.cpp
similarity index 93%
rename from test/unit/core/type_traits/range_iterator_test.cpp
rename to test/unit/core/range/range_iterator_test.cpp
index 8b6d49005e..86bb406870 100644
--- a/test/unit/core/type_traits/range_iterator_test.cpp
+++ b/test/unit/core/range/range_iterator_test.cpp
@@ -13,6 +13,7 @@
 
 #include <meta/meta.hpp>
 
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/detail/random_access_iterator.hpp>
 #include <seqan3/range/views/take_exactly.hpp>
 #include <seqan3/utility/detail/type_name_as_string.hpp>
@@ -292,22 +293,3 @@ TEST(range_and_iterator, range_dimension_v)
     EXPECT_EQ(1u, seqan3::range_dimension_v<std::vector<int>>);
     EXPECT_EQ(2u, seqan3::range_dimension_v<std::vector<std::vector<int>>>);
 }
-
-TEST(range_and_iterator, range_compatible)
-{
-    // true for "compatible" ranges
-    EXPECT_TRUE((seqan3::range_compatible<std::vector<int>, std::list<int>>));
-    EXPECT_TRUE((seqan3::range_compatible<std::list<std::vector<char>>, std::vector<std::string>>));
-
-    // false for un-"compatible" ranges
-    EXPECT_FALSE((seqan3::range_compatible<std::list<std::vector<char>>, std::string>));
-    EXPECT_FALSE((seqan3::range_compatible<std::list<int>, int>));
-    EXPECT_FALSE((seqan3::range_compatible<std::vector<int>, std::string>));
-
-    // compatible not defined on iterators
-    EXPECT_FALSE((seqan3::range_compatible<std::vector<int>, std::ranges::iterator_t<std::vector<int>>>));
-    EXPECT_FALSE((seqan3::range_compatible<std::vector<int>, std::ranges::iterator_t<std::vector<int> const>>));
-    EXPECT_FALSE((seqan3::range_compatible<std::list<std::vector<char>>,
-                                           std::ranges::iterator_t<std::vector<std::string>>>));
-    EXPECT_FALSE((seqan3::range_compatible<std::list<std::vector<char>>, std::ranges::iterator_t<std::string>>));
-}
diff --git a/test/unit/core/type_traits/CMakeLists.txt b/test/unit/core/type_traits/CMakeLists.txt
deleted file mode 100644
index cb9d3e8593..0000000000
--- a/test/unit/core/type_traits/CMakeLists.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-seqan3_test(basic_test.cpp)
-seqan3_test(deferred_crtp_base_test.cpp)
-seqan3_test(function_test.cpp)
-seqan3_test(lazy_test.cpp)
-seqan3_test(range_iterator_test.cpp)
-seqan3_test(template_inspection_test.cpp)
-seqan3_test(transformation_trait_or_test.cpp)
-seqan3_test(type_traits_iterator_test.cpp)
diff --git a/test/unit/range/views/adaptor_base_test.cpp b/test/unit/range/views/adaptor_base_test.cpp
index 515e725b99..941aae6079 100644
--- a/test/unit/range/views/adaptor_base_test.cpp
+++ b/test/unit/range/views/adaptor_base_test.cpp
@@ -10,8 +10,8 @@
 
 #include <gtest/gtest.h>
 
-#include <seqan3/core/type_traits/basic.hpp>
 #include <seqan3/range/views/detail.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 // The general capabilities of adaptor_base and derivates are tested thoroughly by the different views
 // this file checks the correct memory behaviour in regard to storing the elements
diff --git a/test/unit/range/views/pairwise_combine_test.cpp b/test/unit/range/views/pairwise_combine_test.cpp
index be859593a9..8ce5aca5b9 100644
--- a/test/unit/range/views/pairwise_combine_test.cpp
+++ b/test/unit/range/views/pairwise_combine_test.cpp
@@ -15,8 +15,8 @@
 #include <range/v3/algorithm/equal.hpp>
 #include <range/v3/view/filter.hpp>
 
-#include <seqan3/core/type_traits/range.hpp>
 #include <seqan3/core/detail/debug_stream_tuple.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/pairwise_combine.hpp>
 #include <seqan3/range/views/take.hpp>
 #include <seqan3/test/pretty_printing.hpp>
diff --git a/test/unit/range/views/repeat_n_test.cpp b/test/unit/range/views/repeat_n_test.cpp
index 680f0f6b10..22b4511470 100644
--- a/test/unit/range/views/repeat_n_test.cpp
+++ b/test/unit/range/views/repeat_n_test.cpp
@@ -7,13 +7,14 @@
 
 #include <gtest/gtest.h>
 
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/std/algorithm>
+#include <seqan3/std/ranges>
+
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/persist.hpp>
 #include <seqan3/range/views/repeat_n.hpp>
 #include <seqan3/range/views/take.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/ranges>
 #include <seqan3/test/expect_range_eq.hpp>
 
 TEST(general, construction)
diff --git a/test/unit/range/views/repeat_test.cpp b/test/unit/range/views/repeat_test.cpp
index 8570ad1d4f..9f161b1fc2 100644
--- a/test/unit/range/views/repeat_test.cpp
+++ b/test/unit/range/views/repeat_test.cpp
@@ -7,14 +7,15 @@
 
 #include <gtest/gtest.h>
 
-#include <seqan3/core/type_traits/iterator.hpp>
-#include <seqan3/core/type_traits/range.hpp>
+#include <seqan3/std/algorithm>
+#include <seqan3/std/ranges>
+
+#include <seqan3/core/detail/iterator_traits.hpp>
+#include <seqan3/core/range/type_traits.hpp>
 #include <seqan3/range/views/persist.hpp>
 #include <seqan3/range/views/repeat.hpp>
 #include <seqan3/range/views/take.hpp>
 #include <seqan3/range/views/take_exactly.hpp>
-#include <seqan3/std/algorithm>
-#include <seqan3/std/ranges>
 #include <seqan3/test/expect_range_eq.hpp>
 
 TEST(repeat_view, deduction_guide)
diff --git a/test/unit/utility/type_traits/CMakeLists.txt b/test/unit/utility/type_traits/CMakeLists.txt
new file mode 100644
index 0000000000..ca9c3fdcb8
--- /dev/null
+++ b/test/unit/utility/type_traits/CMakeLists.txt
@@ -0,0 +1,4 @@
+seqan3_test(basic_test.cpp)
+seqan3_test(function_traits_test.cpp)
+seqan3_test(lazy_conditional_test.cpp)
+seqan3_test(transformation_trait_or_test.cpp)
diff --git a/test/unit/core/type_traits/basic_test.cpp b/test/unit/utility/type_traits/basic_test.cpp
similarity index 96%
rename from test/unit/core/type_traits/basic_test.cpp
rename to test/unit/utility/type_traits/basic_test.cpp
index 5b2e0098e9..7d03c8303b 100644
--- a/test/unit/core/type_traits/basic_test.cpp
+++ b/test/unit/utility/type_traits/basic_test.cpp
@@ -6,16 +6,12 @@
 // -----------------------------------------------------------------------------------------------------
 
 #include <list>
-#include <vector>
 
 #include <gtest/gtest.h>
 
 #include <meta/meta.hpp>
 
-#include <range/v3/view/iota.hpp>
-#include <range/v3/view/take_exactly.hpp>
-
-#include <seqan3/core/type_traits/basic.hpp>
+#include <seqan3/utility/type_traits/basic.hpp>
 
 //------------------------------------------------------------------------------
 // Tests for remove_cvref transformation trait
diff --git a/test/unit/core/type_traits/function_test.cpp b/test/unit/utility/type_traits/function_traits_test.cpp
similarity index 97%
rename from test/unit/core/type_traits/function_test.cpp
rename to test/unit/utility/type_traits/function_traits_test.cpp
index d14d921805..ecad903647 100644
--- a/test/unit/core/type_traits/function_test.cpp
+++ b/test/unit/utility/type_traits/function_traits_test.cpp
@@ -9,7 +9,7 @@
 
 #include <string>
 
-#include <seqan3/core/type_traits/function.hpp>
+#include <seqan3/utility/type_traits/function_traits.hpp>
 
 std::function test_function_object = [] (size_t arg1, std::string & arg2)
 {
diff --git a/test/unit/core/type_traits/lazy_test.cpp b/test/unit/utility/type_traits/lazy_conditional_test.cpp
similarity index 98%
rename from test/unit/core/type_traits/lazy_test.cpp
rename to test/unit/utility/type_traits/lazy_conditional_test.cpp
index 2b0bd2dadc..db78ec26a6 100644
--- a/test/unit/core/type_traits/lazy_test.cpp
+++ b/test/unit/utility/type_traits/lazy_conditional_test.cpp
@@ -7,11 +7,11 @@
 
 #include <gtest/gtest.h>
 
+#include <seqan3/std/concepts>
 #include <list>
 #include <vector>
 
-#include <seqan3/core/type_traits/lazy.hpp>
-#include <seqan3/std/concepts>
+#include <seqan3/utility/type_traits/lazy_conditional.hpp>
 
 TEST(lazy, instantiate)
 {
diff --git a/test/unit/core/type_traits/transformation_trait_or_test.cpp b/test/unit/utility/type_traits/transformation_trait_or_test.cpp
similarity index 94%
rename from test/unit/core/type_traits/transformation_trait_or_test.cpp
rename to test/unit/utility/type_traits/transformation_trait_or_test.cpp
index e41432dfee..b4fc69b582 100644
--- a/test/unit/core/type_traits/transformation_trait_or_test.cpp
+++ b/test/unit/utility/type_traits/transformation_trait_or_test.cpp
@@ -7,7 +7,7 @@
 
 #include <gtest/gtest.h>
 
-#include <seqan3/core/type_traits/transformation_trait_or.hpp>
+#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
 struct A
 {