diff --git a/include/iris/colorize_format.hpp b/include/iris/colorize_format.hpp
index 55ca870..e9d033d 100644
--- a/include/iris/colorize_format.hpp
+++ b/include/iris/colorize_format.hpp
@@ -6,8 +6,7 @@
 #include <iris/config.hpp> // IWYU pragma: keep
 
 #include <iris/string.hpp>
-#include <iris/enum_bitops.hpp>
-#include <iris/enum_bitops_algorithm.hpp>
+#include <iris/enum/enum.hpp>
 #include <iris/fixed_string.hpp>
 
 #include <algorithm>
@@ -474,10 +473,13 @@ static constexpr std::uint8_t emphasis_to_value(emphasis em)
 } // ansi_colorize
 
 template<>
-struct bitops_enabled<ansi_colorize::detail::emphasis> : std::true_type {
+struct enum_traits<ansi_colorize::detail::emphasis>
+{
     static constexpr int max_bit = 7;
 };
 
+static_assert(Enum<ansi_colorize::detail::emphasis>);
+
 namespace ansi_colorize {
 
 struct colorize_style
@@ -672,7 +674,7 @@ struct colorizer
             style.fg_color = color;
 
         } else if (auto emphasis = detail::name_to_emphasis(specifier); emphasis != detail::emphasis{}) {
-            using namespace bitops_operators;
+            using namespace enum_bitops_operators;
             style.emphasis |= emphasis;
 
         } else if (specifier.starts_with("fg:")) {
diff --git a/include/iris/enum/enum.hpp b/include/iris/enum/enum.hpp
new file mode 100644
index 0000000..60dd449
--- /dev/null
+++ b/include/iris/enum/enum.hpp
@@ -0,0 +1,269 @@
+#ifndef IRIS_ZZ_ENUM_ENUM_HPP
+#define IRIS_ZZ_ENUM_ENUM_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <format>
+#include <limits>
+#include <ranges>
+#include <utility>
+#include <array>
+#include <concepts>
+#include <type_traits>
+#include <numbers>
+
+#ifndef NDEBUG
+#include <bit>
+#endif
+
+#include <cassert>
+#include <cstddef> // IWYU pragma: keep
+
+namespace iris {
+
+namespace detail {
+
+struct enum_traits_not_defined {};
+
+} // detail
+
+template<class EnumT>
+struct enum_traits : detail::enum_traits_not_defined
+{};
+
+template<class EnumT>
+concept Enum = std::is_enum_v<EnumT> && requires {
+    typename enum_traits<EnumT>;
+    requires !std::derived_from<enum_traits<EnumT>, detail::enum_traits_not_defined>;
+};
+
+namespace detail {
+
+template<class EnumT>
+concept enum_has_finite_minmax_element = requires {
+    requires std::same_as<std::remove_const_t<decltype(enum_traits<EnumT>::min_element)>, EnumT>;
+    requires std::same_as<std::remove_const_t<decltype(enum_traits<EnumT>::max_element)>, EnumT>;
+    requires std::to_underlying(enum_traits<EnumT>::min_element) <= std::to_underlying(enum_traits<EnumT>::max_element);
+};
+
+template<class EnumT>
+concept enum_has_min_bit = requires {
+    requires std::same_as<std::remove_const_t<decltype(enum_traits<EnumT>::min_bit)>, int>;
+};
+template<class EnumT>
+concept enum_has_proper_min_bit = !requires { enum_traits<EnumT>::min_bit; } || enum_has_min_bit<EnumT>;
+
+template<class EnumT>
+constexpr int enum_min_bit_v = 0;
+
+template<class EnumT>
+    requires enum_has_min_bit<EnumT>
+constexpr int enum_min_bit_v<EnumT> = enum_traits<EnumT>::min_bit;
+
+
+template<class EnumT>
+concept enum_has_max_bit = requires {
+    requires std::same_as<std::remove_const_t<decltype(enum_traits<EnumT>::max_bit)>, int>;
+};
+template<class EnumT>
+concept enum_has_proper_max_bit = !requires { enum_traits<EnumT>::max_bit; } || enum_has_max_bit<EnumT>;
+
+template<class EnumT>
+concept enum_has_finite_minmax_bit =
+    std::unsigned_integral<std::underlying_type_t<EnumT>> &&
+    enum_has_proper_min_bit<EnumT> &&
+    enum_has_proper_max_bit<EnumT> &&
+    requires {
+        requires enum_min_bit_v<EnumT> <= enum_traits<EnumT>::max_bit;
+    };
+
+template<class EnumT>
+struct enum_count_impl;
+
+template<class EnumT>
+    requires detail::enum_has_finite_minmax_bit<EnumT>
+struct enum_count_impl<EnumT>
+    : std::integral_constant<std::size_t, enum_traits<EnumT>::max_bit + 1 - detail::enum_min_bit_v<EnumT>>
+{};
+
+template<class EnumT>
+    requires detail::enum_has_finite_minmax_element<EnumT> && (!detail::enum_has_finite_minmax_bit<EnumT>)
+struct enum_count_impl<EnumT>
+    : std::integral_constant<
+        std::size_t,
+        static_cast<std::size_t>(enum_traits<EnumT>::max_element) + 1uz -
+        static_cast<std::size_t>(enum_traits<EnumT>::min_element)
+    >
+{};
+
+} // detail
+
+
+template<class EnumT>
+concept FiniteEnum = Enum<EnumT> && (detail::enum_has_finite_minmax_bit<EnumT> || detail::enum_has_finite_minmax_element<EnumT>);
+
+template<FiniteEnum EnumT>
+constexpr std::size_t enum_count_v = detail::enum_count_impl<EnumT>::value;
+
+template<class EnumT>
+concept BitopsEnabledEnum =
+    Enum<EnumT> &&
+    std::unsigned_integral<std::underlying_type_t<EnumT>> &&
+    detail::enum_has_proper_min_bit<EnumT> &&
+    detail::enum_has_proper_max_bit<EnumT>;
+
+
+template<Enum EnumT>
+[[nodiscard]] consteval auto enum_values() noexcept
+{
+    static_assert(FiniteEnum<EnumT>);
+
+    if constexpr (detail::enum_has_finite_minmax_bit<EnumT>) {
+        return []<int... Offsets>(std::integer_sequence<int, Offsets...>) noexcept {
+            return std::array<EnumT, enum_count_v<EnumT>>{
+                static_cast<EnumT>(1u << (detail::enum_min_bit_v<EnumT> + Offsets))...
+            };
+        }(std::make_integer_sequence<int, static_cast<int>(enum_count_v<EnumT>)>{});
+
+    } else {
+        constexpr auto first_val = std::to_underlying(enum_traits<EnumT>::min_element);
+        return []<class T, auto... Offsets>(std::integer_sequence<T, Offsets...>) noexcept {
+            return std::array<EnumT, enum_count_v<EnumT>>{
+                static_cast<EnumT>(first_val + Offsets)...
+            };
+        }(std::make_integer_sequence<std::underlying_type_t<EnumT>, enum_count_v<EnumT>>{});
+    }
+}
+
+
+inline namespace enum_bitops_operators {
+
+template<BitopsEnabledEnum EnumT>
+[[nodiscard]] constexpr EnumT operator~(EnumT a) noexcept
+{
+    return static_cast<EnumT>(~std::to_underlying(a));
+}
+
+template<BitopsEnabledEnum EnumT>
+[[nodiscard]] constexpr EnumT operator|(EnumT a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return static_cast<EnumT>(std::to_underlying(a) | std::to_underlying(b));
+}
+
+template<BitopsEnabledEnum EnumT>
+constexpr EnumT& operator|=(EnumT& a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return a = a | b;
+}
+
+template<BitopsEnabledEnum EnumT>
+[[nodiscard]] constexpr EnumT operator&(EnumT a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return static_cast<EnumT>(std::to_underlying(a) & std::to_underlying(b));
+}
+
+template<BitopsEnabledEnum EnumT>
+constexpr EnumT& operator&=(EnumT& a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return a = a & b;
+}
+
+template<BitopsEnabledEnum EnumT>
+[[nodiscard]] constexpr EnumT operator^(EnumT a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return static_cast<EnumT>(std::to_underlying(a) ^ std::to_underlying(b));
+}
+
+template<BitopsEnabledEnum EnumT>
+constexpr EnumT& operator^=(EnumT& a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return a = a ^ b;
+}
+
+} // enum_bitops_operators
+
+template<BitopsEnabledEnum EnumT>
+[[nodiscard]] constexpr bool contains(EnumT a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return (std::to_underlying(a) & std::to_underlying(b)) == std::to_underlying(b);
+}
+
+template<BitopsEnabledEnum EnumT>
+[[nodiscard]] constexpr bool contains_single_bit(EnumT a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    assert(std::has_single_bit(std::to_underlying(b)));
+    return std::to_underlying(a) & std::to_underlying(b);
+}
+
+template<BitopsEnabledEnum EnumT>
+[[nodiscard]] constexpr bool contains_any_bit(EnumT a, EnumT b) noexcept
+{
+    static_assert(std::is_unsigned_v<std::underlying_type_t<EnumT>>);
+    return std::to_underlying(a) & std::to_underlying(b);
+}
+
+
+namespace detail {
+
+struct each_bit_fn
+{
+    template<FiniteEnum EnumT>
+        requires
+            BitopsEnabledEnum<EnumT> &&
+            requires {
+                requires enum_traits<EnumT>::max_bit < std::numeric_limits<std::underlying_type_t<EnumT>>::digits;
+            }
+    [[nodiscard]] static constexpr auto operator()(EnumT flags) noexcept
+    {
+        return std::views::iota(enum_min_bit_v<EnumT>, enum_traits<EnumT>::max_bit + 1)
+            | std::views::filter([cat = std::to_underlying(flags)](int i) constexpr noexcept -> bool { return (cat >> i) & 1; })
+            | std::views::transform([](int i) constexpr noexcept { return static_cast<EnumT>(static_cast<std::underlying_type_t<EnumT>>(1u) << i); });
+    }
+};
+
+} // detail
+
+inline constexpr detail::each_bit_fn each_bit{};
+
+} // iris
+
+template<iris::Enum EnumT, class CharT>
+    requires requires(EnumT const& val) {
+        { to_string(val) } -> std::formattable<CharT>;
+    }
+struct std::formatter<EnumT, CharT> : std::formatter<std::underlying_type_t<EnumT>, CharT>
+{
+    using base_formatter = std::formatter<std::underlying_type_t<EnumT>, CharT>;
+
+    template<class Context>
+    constexpr auto parse(Context& ctx)
+    {
+        if (ctx.begin() == ctx.end()) return ctx.end();
+        has_format_spec_ = true;
+        return base_formatter::parse(ctx);
+    }
+
+    template<class Context>
+    auto format(EnumT const& val, Context& ctx) const
+    {
+        if (has_format_spec_) {
+            return base_formatter::format(std::to_underlying(val), ctx);
+        }
+        return format_to(ctx.out(), "{}", to_string(val));
+    }
+
+private:
+    bool has_format_spec_ = false;
+};
+
+#endif
diff --git a/include/iris/enum/io.hpp b/include/iris/enum/io.hpp
new file mode 100644
index 0000000..2f113d8
--- /dev/null
+++ b/include/iris/enum/io.hpp
@@ -0,0 +1,68 @@
+#ifndef IRIS_ZZ_ENUM_IO_HPP
+#define IRIS_ZZ_ENUM_IO_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/enum/enum.hpp>
+#include <iris/string.hpp>
+
+#include <ostream> // IWYU pragma: keep
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace iris {
+
+inline namespace enum_operators {
+
+template<Enum T>
+std::ostream& operator<<(std::ostream& os, T const& val)
+{
+    using std::to_string;
+
+    if constexpr (requires {
+        { os << to_string(val) } -> std::convertible_to<std::ostream&>;
+    }) {
+        return os << to_string(val);
+    } else {
+        return os << std::to_underlying(val);
+    }
+}
+
+} // enum_operators
+
+template<BitopsEnabledEnum T>
+[[nodiscard]] constexpr T parse_flag(StringLike auto const& str) noexcept
+{
+    return enum_traits<T>::parse(std::basic_string_view{str});
+}
+
+template<BitopsEnabledEnum T>
+[[nodiscard]] constexpr T parse_flags(StringLike auto const& str, StringLike auto const& delim) noexcept
+{
+    using namespace iris::enum_bitops_operators;
+
+    std::basic_string_view str_sv{str};
+    std::basic_string_view delim_sv{delim};
+
+    T res{};
+
+    for (auto const& r : str_sv | std::views::split(delim_sv)) {
+        std::basic_string_view const part_str{r.begin(), r.end()};
+
+        auto const part = iris::parse_flag<T>(part_str);
+        if (part == T{}) {
+            return T{};
+        }
+        res |= part;
+    }
+
+    return res;
+}
+
+} // iris
+
+#endif
diff --git a/include/iris/enum_bitops.hpp b/include/iris/enum_bitops.hpp
deleted file mode 100644
index 4b01d11..0000000
--- a/include/iris/enum_bitops.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef IRIS_ZZ_ENUM_BITOPS_HPP
-#define IRIS_ZZ_ENUM_BITOPS_HPP
-
-// SPDX-License-Identifier: MIT
-
-#include <iris/config.hpp> // IWYU pragma: keep
-
-#include <concepts>
-#include <type_traits>
-#include <utility>
-
-#ifndef NDEBUG
-#include <bit>
-#endif
-
-#include <cassert>
-
-namespace iris {
-
-template<class T>
-struct bitops_enabled : std::false_type {};
-
-template<class T>
-constexpr bool bitops_enabled_v = bitops_enabled<T>::value;
-
-namespace detail {
-
-template<class T>
-concept bitops_enum_has_min_bit = std::same_as<std::remove_const_t<decltype(bitops_enabled<T>::min_bit)>, int>;
-
-template<class T>
-concept bitops_enum_has_max_bit = std::same_as<std::remove_const_t<decltype(bitops_enabled<T>::max_bit)>, int>;
-
-} // detail
-
-template<class T>
-concept BitopsEnabledEnum = std::is_enum_v<T> && bitops_enabled_v<T>;
-
-inline namespace bitops_operators {
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr T operator~(T a) noexcept
-{
-    return static_cast<T>(~std::to_underlying(a));
-}
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr T operator|(T a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return static_cast<T>(std::to_underlying(a) | std::to_underlying(b));
-}
-
-template<BitopsEnabledEnum T>
-constexpr T& operator|=(T& a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return a = a | b;
-}
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr T operator&(T a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return static_cast<T>(std::to_underlying(a) & std::to_underlying(b));
-}
-
-template<BitopsEnabledEnum T>
-constexpr T& operator&=(T& a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return a = a & b;
-}
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr T operator^(T a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return static_cast<T>(std::to_underlying(a) ^ std::to_underlying(b));
-}
-
-template<BitopsEnabledEnum T>
-constexpr T& operator^=(T& a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return a = a ^ b;
-}
-
-} // bitops_operators
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr bool contains(T a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return (std::to_underlying(a) & std::to_underlying(b)) == std::to_underlying(b);
-}
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr bool contains_single_bit(T a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    assert(std::has_single_bit(std::to_underlying(b)));
-    return std::to_underlying(a) & std::to_underlying(b);
-}
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr bool contains_any_bit(T a, T b) noexcept
-{
-    static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-    return std::to_underlying(a) & std::to_underlying(b);
-}
-
-} // iris
-
-#endif
diff --git a/include/iris/enum_bitops_algorithm.hpp b/include/iris/enum_bitops_algorithm.hpp
deleted file mode 100644
index 875633f..0000000
--- a/include/iris/enum_bitops_algorithm.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef IRIS_ZZ_ENUM_BITOPS_ALGORITHM_HPP
-#define IRIS_ZZ_ENUM_BITOPS_ALGORITHM_HPP
-
-// SPDX-License-Identifier: MIT
-
-#include <iris/config.hpp> // IWYU pragma: keep
-
-#include <iris/enum_bitops.hpp>
-
-#include <limits>
-#include <ranges>
-#include <utility>
-
-namespace iris {
-
-namespace detail {
-
-struct each_bit_fn
-{
-    template<BitopsEnabledEnum T>
-    [[nodiscard]] static constexpr auto operator()(T flags) noexcept
-    {
-        static_assert(std::is_unsigned_v<std::underlying_type_t<T>>);
-        static_assert(detail::bitops_enum_has_max_bit<T>);
-        static_assert(bitops_enabled<T>::max_bit < std::numeric_limits<std::underlying_type_t<T>>::digits);
-
-        if constexpr (detail::bitops_enum_has_min_bit<T>) {
-        static_assert(bitops_enabled<T>::min_bit <= bitops_enabled<T>::max_bit);
-            return std::views::iota(bitops_enabled<T>::min_bit, bitops_enabled<T>::max_bit + 1)
-                | std::views::filter([cat = std::to_underlying(flags)](int i) constexpr noexcept -> bool { return (cat >> i) & 1; })
-                | std::views::transform([](int i) constexpr noexcept { return static_cast<T>(static_cast<std::underlying_type_t<T>>(1) << i); });
-        } else {
-            return std::views::iota(0, bitops_enabled<T>::max_bit + 1)
-                | std::views::filter([cat = std::to_underlying(flags)](int i) constexpr noexcept -> bool { return (cat >> i) & 1; })
-                | std::views::transform([](int i) constexpr noexcept { return static_cast<T>(static_cast<std::underlying_type_t<T>>(1) << i); });
-        }
-    }
-};
-
-} // detail
-
-inline constexpr detail::each_bit_fn each_bit{};
-
-} // iris
-
-#endif
diff --git a/include/iris/enum_bitops_io.hpp b/include/iris/enum_bitops_io.hpp
deleted file mode 100644
index 2e76cde..0000000
--- a/include/iris/enum_bitops_io.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef IRIS_ZZ_ENUM_BITOPS_IO_HPP
-#define IRIS_ZZ_ENUM_BITOPS_IO_HPP
-
-// SPDX-License-Identifier: MIT
-
-#include <iris/config.hpp> // IWYU pragma: keep
-
-#include <iris/string.hpp>
-#include <iris/enum_bitops.hpp>
-
-#include <ostream>
-#include <format>
-#include <ranges>
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace iris {
-
-inline namespace bitops_operators {
-
-template<BitopsEnabledEnum T>
-std::ostream& operator<<(std::ostream& os, T const& val)
-{
-    using std::to_string;
-
-    if constexpr (requires {
-        { to_string(val) } -> std::convertible_to<std::string const&>;
-    }) {
-        return os << to_string(val);
-    } else {
-        return os << std::to_underlying(val);
-    }
-}
-
-} // bitops_operators
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr T parse_flag(StringLike auto const& str) noexcept
-{
-    return bitops_enabled<T>::parse(std::basic_string_view{str});
-}
-
-template<BitopsEnabledEnum T>
-[[nodiscard]] constexpr T parse_flags(StringLike auto const& str, StringLike auto const& delim) noexcept
-{
-    using namespace iris::bitops_operators;
-
-    std::basic_string_view str_sv{str};
-    std::basic_string_view delim_sv{delim};
-
-    T res{};
-
-    for (auto const& r : str_sv | std::views::split(delim_sv)) {
-        std::basic_string_view const part_str{r.begin(), r.end()};
-
-        auto const part = iris::parse_flag<T>(part_str);
-        if (part == T{}) {
-            return T{};
-        }
-        res |= part;
-    }
-
-    return res;
-}
-
-} // iris
-
-namespace std {
-
-template<::iris::BitopsEnabledEnum T, class CharT>
-struct formatter<T, CharT> : formatter<std::underlying_type_t<T>, CharT>
-{
-    using base_formatter = formatter<std::underlying_type_t<T>, CharT>;
-
-    template<class Context>
-    constexpr auto parse(Context& ctx)
-    {
-        if (ctx.begin() == ctx.end()) return ctx.end();
-        has_format_spec_ = true;
-        return base_formatter::parse(ctx);
-    }
-
-    template<class Context>
-    auto format(T const& val, Context& ctx) const
-    {
-        if (has_format_spec_) {
-            return base_formatter::format(std::to_underlying(val), ctx);
-        }
-        return format_to(ctx.out(), "{}", to_string(val));
-    }
-
-private:
-    bool has_format_spec_ = false;
-};
-
-} // std
-
-#endif
diff --git a/test/enum.cpp b/test/enum.cpp
index 6de3afd..285b0fa 100644
--- a/test/enum.cpp
+++ b/test/enum.cpp
@@ -2,37 +2,95 @@
 
 #include "iris_test.hpp"
 
-#include <iris/enum_bitops.hpp>
-#include <iris/enum_bitops_algorithm.hpp>
-#include <iris/enum_bitops_io.hpp>
+#include <iris/enum/enum.hpp>
+#include <iris/enum/io.hpp>
 
 #include <algorithm>
-#include <ranges>
 #include <string_view>
 #include <utility>
 #include <vector>
 
 #include <cstdint>
 
+enum PlainEnum {};
+enum struct PlainScopedEnum {};
+
+enum struct Enum_0_4 : unsigned {};
+enum struct Enum_2_4 : unsigned {};
+
+enum struct BitEnum_0_4 : unsigned {};
+enum struct BitEnum_2_4 : unsigned {};
+
+template<>
+struct iris::enum_traits<Enum_0_4>
+{
+    static constexpr Enum_0_4 max_element = Enum_0_4{0};
+};
+template<>
+struct iris::enum_traits<Enum_2_4>
+{
+    static constexpr Enum_2_4 min_element = Enum_2_4{2};
+    static constexpr Enum_2_4 max_element = Enum_2_4{4};
+};
+
+template<>
+struct iris::enum_traits<BitEnum_0_4>
+{
+    static constexpr int max_bit = 4;
+};
+template<>
+struct iris::enum_traits<BitEnum_2_4>
+{
+    static constexpr int min_bit = 2;
+    static constexpr int max_bit = 4;
+};
+
+TEST_CASE("enum")
+{
+    STATIC_CHECK(!iris::Enum<PlainEnum>);
+    STATIC_CHECK(!iris::Enum<PlainScopedEnum>);
+
+    STATIC_CHECK(iris::BitopsEnabledEnum<Enum_0_4>);
+    STATIC_CHECK(!iris::FiniteEnum<Enum_0_4>);
+
+    STATIC_CHECK(iris::BitopsEnabledEnum<Enum_2_4>);
+    STATIC_CHECK(iris::FiniteEnum<Enum_2_4>);
+    STATIC_CHECK(iris::enum_count_v<Enum_2_4> == 3);
+    STATIC_CHECK(iris::enum_values<Enum_2_4>() == std::array{Enum_2_4{2}, Enum_2_4{3}, Enum_2_4{4}});
+
+    STATIC_CHECK(iris::BitopsEnabledEnum<BitEnum_0_4>);
+    STATIC_CHECK(iris::FiniteEnum<BitEnum_0_4>);
+    STATIC_CHECK(iris::enum_count_v<BitEnum_0_4> == 5);
+    STATIC_CHECK(iris::enum_values<BitEnum_0_4>() == std::array{BitEnum_0_4{1u << 0}, BitEnum_0_4{1u << 1}, BitEnum_0_4{1u << 2}, BitEnum_0_4{1u << 3}, BitEnum_0_4{1u << 4}});
+
+    STATIC_CHECK(iris::BitopsEnabledEnum<BitEnum_2_4>);
+    STATIC_CHECK(iris::FiniteEnum<BitEnum_2_4>);
+    STATIC_CHECK(iris::enum_count_v<BitEnum_2_4> == 3);
+    STATIC_CHECK(iris::enum_values<BitEnum_2_4>() == std::array{BitEnum_2_4{1u << 2}, BitEnum_2_4{1u << 3}, BitEnum_2_4{1u << 4}});
+}
+
 enum class MyFlags : std::uint8_t
 {
-    FOO = 1 << 0,
-    BAR = 1 << 1,
-    BAZ = 1 << 2,
+    NO_FLAGS = 0u,
+    FOO = 1u << 0,
+    BAR = 1u << 1,
+    BAZ = 1u << 2,
 };
 
 enum class SpellType : std::uint8_t
 {
-    TYPE_ATTACK  = 1 << 0,
-    TYPE_DEFENSE = 1 << 1,
+    NO_SPELL_TYPE = 0u,
+
+    TYPE_ATTACK  = 1u << 0,
+    TYPE_DEFENSE = 1u << 1,
 
-    ATTR_FIRE    = 1 << 2,
-    ATTR_WATER   = 1 << 3,
-    ATTR_THUNDER = 1 << 4,
+    ATTR_FIRE    = 1u << 2,
+    ATTR_WATER   = 1u << 3,
+    ATTR_THUNDER = 1u << 4,
 };
 
 template<>
-struct iris::bitops_enabled<MyFlags> : std::true_type
+struct iris::enum_traits<MyFlags>
 {
     static MyFlags parse(std::string_view sv) noexcept
     {
@@ -45,18 +103,20 @@ struct iris::bitops_enabled<MyFlags> : std::true_type
 };
 
 template<>
-struct iris::bitops_enabled<SpellType> : std::true_type
+struct iris::enum_traits<SpellType>
 {
     static constexpr int min_bit = 2;
     static constexpr int max_bit = 4;
 };
 
-TEST_CASE("enum")
+TEST_CASE("enum: flags")
 {
-    using namespace iris::bitops_operators;
+    using namespace iris::enum_bitops_operators;
 
     using enum MyFlags;
 
+    static_assert(iris::Enum<MyFlags>);
+
     CHECK((~FOO == static_cast<MyFlags>(~std::to_underlying(FOO))));
 
     CHECK(((FOO & BAR) == static_cast<MyFlags>(std::to_underlying(FOO) & std::to_underlying(BAR))));
@@ -96,6 +156,8 @@ TEST_CASE("enum")
     CHECK((iris::parse_flags<MyFlags>("foo|yay", "|") == MyFlags{}));
     CHECK((iris::parse_flags<MyFlags>("foo,bar", "|") == MyFlags{}));
 
+    static_assert(iris::detail::enum_has_finite_minmax_bit<SpellType>);
+
     CHECK(std::ranges::equal(
         iris::each_bit(SpellType::TYPE_ATTACK | SpellType::ATTR_FIRE | SpellType::ATTR_THUNDER),
         std::vector{SpellType::ATTR_FIRE, SpellType::ATTR_THUNDER}
diff --git a/test/library_config.cpp b/test/library_config.cpp
index 9f025b3..3b4dbd4 100644
--- a/test/library_config.cpp
+++ b/test/library_config.cpp
@@ -53,9 +53,8 @@
 #include <iris/cond_trivial_smf.hpp>
 #include <iris/config.hpp>
 #include <iris/default_init_allocator.hpp>
-#include <iris/enum_bitops.hpp>
-#include <iris/enum_bitops_algorithm.hpp>
-#include <iris/enum_bitops_io.hpp>
+#include <iris/enum/enum.hpp>
+#include <iris/enum/io.hpp>
 #include <iris/exception.hpp>
 #include <iris/fixed_string.hpp>
 #include <iris/format.hpp>