diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 00000000..6bb9c763
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,8 @@
+Checks: |
+  -misc-unused-using-decls
+  -misc-include-cleaner
+  -modernize-use-using
+  -readability-duplicate-include
+  -readability-redundant-preprocessor
+HeaderFilterRegex: \./.+\\.(h|hpp)$
+WarningsAsErrors: false
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 717adbff..8faac8de 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,7 @@
 cmake_minimum_required(VERSION 3.23)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 option(REFLECTCPP_BUILD_SHARED "Build shared library" ${BUILD_SHARED_LIBS})
 option(REFLECTCPP_INSTALL "Install reflect cpp" OFF)
 
@@ -154,9 +156,27 @@ endif()
 add_library(reflectcpp::reflectcpp ALIAS reflectcpp)
 
 if (MSVC)
-    target_compile_options(reflectcpp PRIVATE $<$<CONFIG:Debug>:-Wall>)
+    target_compile_options(reflectcpp PRIVATE 
+        $<$<CONFIG:Debug>:
+            -Wall
+        >
+        $<$<CONFIG:Release>:
+            -DNDEBUG
+        >
+    )
 else()
-    target_compile_options(reflectcpp PRIVATE $<$<CONFIG:Debug>:-Wall -Wextra>)
+    target_compile_options(reflectcpp PRIVATE
+        $<$<CONFIG:Debug>:
+            -Wall -Wextra -Wpedantic -Wshadow -Wconversion
+            #-Wnull-dereference -Wold-style-cast
+            #-g3 -fno-omit-frame-pointer
+            #-fsanitize=address,undefined
+            #-fno-sanitize-recover=undefined
+        >
+        $<$<CONFIG:Release>:
+            -DNDEBUG
+        >
+    )
 endif()
 
 if(REFLECTCPP_USE_STD_EXPECTED)
diff --git a/benchmarks/all/canada_read.cpp b/benchmarks/all/canada_read.cpp
index 3053ce7d..9449a74b 100644
--- a/benchmarks/all/canada_read.cpp
+++ b/benchmarks/all/canada_read.cpp
@@ -1,8 +1,5 @@
 #include <benchmark/benchmark.h>
 
-#include <array>
-#include <iostream>
-#include <optional>
 #include <rfl/avro.hpp>
 #include <rfl/bson.hpp>
 #include <rfl/capnproto.hpp>
@@ -13,7 +10,6 @@
 #include <rfl/toml.hpp>
 #include <rfl/ubjson.hpp>
 #include <rfl/yaml.hpp>
-#include <type_traits>
 #include <vector>
 
 namespace canada_read {
diff --git a/benchmarks/all/canada_write.cpp b/benchmarks/all/canada_write.cpp
index cdb0beae..80a817b0 100644
--- a/benchmarks/all/canada_write.cpp
+++ b/benchmarks/all/canada_write.cpp
@@ -1,8 +1,5 @@
 #include <benchmark/benchmark.h>
 
-#include <array>
-#include <iostream>
-#include <optional>
 #include <rfl/avro.hpp>
 #include <rfl/bson.hpp>
 #include <rfl/capnproto.hpp>
@@ -13,7 +10,6 @@
 #include <rfl/toml.hpp>
 #include <rfl/ubjson.hpp>
 #include <rfl/yaml.hpp>
-#include <type_traits>
 #include <vector>
 
 namespace canada_write {
diff --git a/benchmarks/all/licenses_read.cpp b/benchmarks/all/licenses_read.cpp
index e0a5f9cd..2bbb3a7a 100644
--- a/benchmarks/all/licenses_read.cpp
+++ b/benchmarks/all/licenses_read.cpp
@@ -1,7 +1,5 @@
 #include <benchmark/benchmark.h>
 
-#include <array>
-#include <iostream>
 #include <optional>
 #include <rfl/avro.hpp>
 #include <rfl/bson.hpp>
@@ -14,7 +12,6 @@
 #include <rfl/ubjson.hpp>
 #include <rfl/xml.hpp>
 #include <rfl/yaml.hpp>
-#include <type_traits>
 #include <vector>
 
 namespace licenses_read {
diff --git a/benchmarks/all/licenses_write.cpp b/benchmarks/all/licenses_write.cpp
index ee9fe84c..db9f9a87 100644
--- a/benchmarks/all/licenses_write.cpp
+++ b/benchmarks/all/licenses_write.cpp
@@ -1,7 +1,5 @@
 #include <benchmark/benchmark.h>
 
-#include <array>
-#include <iostream>
 #include <optional>
 #include <rfl/avro.hpp>
 #include <rfl/bson.hpp>
@@ -14,7 +12,6 @@
 #include <rfl/ubjson.hpp>
 #include <rfl/xml.hpp>
 #include <rfl/yaml.hpp>
-#include <type_traits>
 #include <vector>
 
 namespace licenses_write {
diff --git a/benchmarks/all/person_read.cpp b/benchmarks/all/person_read.cpp
index 85c723ee..9db2e769 100644
--- a/benchmarks/all/person_read.cpp
+++ b/benchmarks/all/person_read.cpp
@@ -1,8 +1,5 @@
 #include <benchmark/benchmark.h>
 
-#include <array>
-#include <iostream>
-#include <optional>
 #include <rfl/avro.hpp>
 #include <rfl/bson.hpp>
 #include <rfl/capnproto.hpp>
@@ -14,7 +11,6 @@
 #include <rfl/ubjson.hpp>
 #include <rfl/xml.hpp>
 #include <rfl/yaml.hpp>
-#include <type_traits>
 #include <vector>
 namespace person_read {
 
diff --git a/benchmarks/all/person_write.cpp b/benchmarks/all/person_write.cpp
index 0f5e13fe..02fafda8 100644
--- a/benchmarks/all/person_write.cpp
+++ b/benchmarks/all/person_write.cpp
@@ -1,8 +1,5 @@
 #include <benchmark/benchmark.h>
 
-#include <array>
-#include <iostream>
-#include <optional>
 #include <rfl/avro.hpp>
 #include <rfl/bson.hpp>
 #include <rfl/capnproto.hpp>
@@ -14,7 +11,6 @@
 #include <rfl/ubjson.hpp>
 #include <rfl/xml.hpp>
 #include <rfl/yaml.hpp>
-#include <type_traits>
 #include <vector>
 
 namespace person_write {
diff --git a/benchmarks/json/canada.cpp b/benchmarks/json/canada.cpp
index b857f765..223ba5cb 100644
--- a/benchmarks/json/canada.cpp
+++ b/benchmarks/json/canada.cpp
@@ -2,12 +2,9 @@
 #include <rapidjson/document.h>
 #include <simdjson.h>
 
-#include <array>
 #include <iostream>
 #include <nlohmann/json.hpp>
-#include <optional>
 #include <rfl/json.hpp>
-#include <type_traits>
 #include <vector>
 
 namespace canada {
diff --git a/benchmarks/json/licenses.cpp b/benchmarks/json/licenses.cpp
index f7d03fae..93688929 100644
--- a/benchmarks/json/licenses.cpp
+++ b/benchmarks/json/licenses.cpp
@@ -2,12 +2,10 @@
 #include <rapidjson/document.h>
 #include <simdjson.h>
 
-#include <array>
 #include <iostream>
 #include <nlohmann/json.hpp>
 #include <optional>
 #include <rfl/json.hpp>
-#include <type_traits>
 #include <vector>
 
 namespace licenses {
diff --git a/benchmarks/json/person.cpp b/benchmarks/json/person.cpp
index af472850..424bbb49 100644
--- a/benchmarks/json/person.cpp
+++ b/benchmarks/json/person.cpp
@@ -5,7 +5,6 @@
 #include <array>
 #include <iostream>
 #include <nlohmann/json.hpp>
-#include <optional>
 #include <rfl/json.hpp>
 #include <type_traits>
 #include <vector>
diff --git a/include/rfl/Box.hpp b/include/rfl/Box.hpp
index 686c34b1..e2fb2b90 100644
--- a/include/rfl/Box.hpp
+++ b/include/rfl/Box.hpp
@@ -2,7 +2,6 @@
 #define RFL_BOX_HPP_
 
 #include <memory>
-#include <stdexcept>
 
 #include "Result.hpp"
 
@@ -146,7 +145,7 @@ namespace std {
 template <class T>
 struct hash<rfl::Box<T>> {
   size_t operator()(const rfl::Box<T>& _b) const {
-    return hash<unique_ptr<T>>()(_b.ptr());
+    return std::hash<std::unique_ptr<T>>{}(_b.ptr());
   }
 };
 
diff --git a/include/rfl/Field.hpp b/include/rfl/Field.hpp
index 24035114..e33fab2b 100644
--- a/include/rfl/Field.hpp
+++ b/include/rfl/Field.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_FIELD_HPP_
 #define RFL_FIELD_HPP_
 
-#include <algorithm>
 #include <string_view>
-#include <tuple>
 #include <type_traits>
 #include <utility>
 
@@ -11,7 +9,6 @@
 #include "default.hpp"
 #include "internal/Array.hpp"
 #include "internal/StringLiteral.hpp"
-#include "internal/to_std_array.hpp"
 #include "internal/wrap_in_rfl_array_t.hpp"
 
 namespace rfl {
diff --git a/include/rfl/Literal.hpp b/include/rfl/Literal.hpp
index f45817c5..341b0b98 100644
--- a/include/rfl/Literal.hpp
+++ b/include/rfl/Literal.hpp
@@ -5,7 +5,6 @@
 #include <cstdint>
 #include <functional>
 #include <string>
-#include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
diff --git a/include/rfl/Ref.hpp b/include/rfl/Ref.hpp
index fce3e6ba..9818a80f 100644
--- a/include/rfl/Ref.hpp
+++ b/include/rfl/Ref.hpp
@@ -129,11 +129,10 @@ inline std::basic_ostream<CharT, Traits>& operator<<(
 }  // namespace rfl
 
 namespace std {
-
 template <class T>
 struct hash<rfl::Ref<T>> {
   size_t operator()(const rfl::Ref<T>& _r) const {
-    return hash<shared_ptr<T>>()(_r.ptr());
+    return std::hash<std::shared_ptr<T>>{}(_r.ptr());
   }
 };
 
diff --git a/include/rfl/Result.hpp b/include/rfl/Result.hpp
index cf67dbf2..4621f2bb 100644
--- a/include/rfl/Result.hpp
+++ b/include/rfl/Result.hpp
@@ -5,12 +5,9 @@
 #include <expected>
 #endif
 
-#include <algorithm>
 #include <array>
 #include <functional>
-#include <iostream>
 #include <new>
-#include <optional>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
diff --git a/include/rfl/Tuple.hpp b/include/rfl/Tuple.hpp
index 828f6659..d88af559 100644
--- a/include/rfl/Tuple.hpp
+++ b/include/rfl/Tuple.hpp
@@ -1,14 +1,7 @@
 #ifndef RFL_TUPLE_HPP_
 #define RFL_TUPLE_HPP_
 
-#include <algorithm>
 #include <array>
-#include <bit>
-#include <cstdint>
-#include <limits>
-#include <memory>
-#include <optional>
-#include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <utility>
diff --git a/include/rfl/Validator.hpp b/include/rfl/Validator.hpp
index 7bf1fbc7..f3a13294 100644
--- a/include/rfl/Validator.hpp
+++ b/include/rfl/Validator.hpp
@@ -1,8 +1,9 @@
 #ifndef RFL_VALIDATOR_HPP_
 #define RFL_VALIDATOR_HPP_
 
+#include <cstddef>
+#include <exception>
 #include <functional>
-#include <string>
 #include <type_traits>
 #include <utility>
 
@@ -110,17 +111,7 @@ struct Validator {
 template <class T, class V, class... Vs>
 inline auto operator<=>(const Validator<T, V, Vs...>& _v1,
                         const Validator<T, V, Vs...>& _v2) {
-#if __cpp_lib_three_way_comparison >= 201907L
   return _v1.value() <=> _v2.value();
-#else
-  if (_v1.value() < _v2.value()) {
-    return std::strong_ordering::less;
-  } else if (_v1.value() > _v2.value()) {
-    return std::strong_ordering::greater;
-  } else {
-    return std::strong_ordering::equal;
-  }
-#endif
 }
 
 template <class T, class V, class... Vs>
diff --git a/include/rfl/avro/Parser.hpp b/include/rfl/avro/Parser.hpp
index 095e6254..706f4caf 100644
--- a/include/rfl/avro/Parser.hpp
+++ b/include/rfl/avro/Parser.hpp
@@ -4,7 +4,7 @@
 #include "../Generic.hpp"
 #include "../Tuple.hpp"
 #include "../always_false.hpp"
-#include "../parsing/Parser.hpp"
+//#include "../parsing/Parser.hpp"
 #include "Reader.hpp"
 #include "Writer.hpp"
 
@@ -82,15 +82,15 @@ struct Parser<avro::Reader, avro::Writer,
   }
 
   template <class P>
-  static void write(const W& _w,
+  static void write(const W& /*_w*/,
                     const internal::Skip<T, _skip_serialization,
-                                         _skip_deserialization>& _skip,
-                    const P& _parent) noexcept {
+                                         _skip_deserialization>& /*_skip*/,
+                    const P& /*_parent*/) noexcept {
     static_assert(always_false_v<P>, "rfl::Skip is unsupported in Avro.");
   }
 
   template <class U>
-  static schema::Type to_schema(U* _definitions) {
+  static schema::Type to_schema(U* /*_definitions*/) {
     static_assert(always_false_v<U>, "rfl::Skip is unsupported in Avro.");
     return schema::Type{};
   }
diff --git a/include/rfl/avro/Reader.hpp b/include/rfl/avro/Reader.hpp
index faea20c4..db02f67e 100644
--- a/include/rfl/avro/Reader.hpp
+++ b/include/rfl/avro/Reader.hpp
@@ -8,7 +8,6 @@
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <vector>
 
 #include "../Bytestring.hpp"
 #include "../Result.hpp"
@@ -91,9 +90,12 @@ struct Reader {
       if (type != AVRO_BOOLEAN) {
         return rfl::error("Could not cast to boolean.");
       }
-      int result = 0;
-      avro_value_get_boolean(_var.val_, &result);
-      return (result != 0);
+      int result_value = 0;
+      int result = avro_value_get_boolean(_var.val_, &result_value);
+      if (result != 0) {
+        return error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+      }
+      return (result_value != 0);
 
     } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
       if (type == AVRO_DOUBLE) {
@@ -188,10 +190,18 @@ struct Reader {
   std::optional<Error> read_array(const ArrayReader& _array_reader,
                                   const InputArrayType& _arr) const noexcept {
     size_t size = 0;
-    avro_value_get_size(_arr.val_, &size);
+    int res = avro_value_get_size(_arr.val_, &size);
+    if(res)
+    {
+      return Error(std::string(__FUNCTION__) + " error(" + std::to_string(res) + "): "  + avro_strerror());
+    }
     for (size_t ix = 0; ix < size; ++ix) {
       avro_value_t element;
-      avro_value_get_by_index(_arr.val_, ix, &element, nullptr);
+      res = avro_value_get_by_index(_arr.val_, ix, &element, nullptr);
+      if(res)
+      {
+      return Error(std::string(__FUNCTION__) + " error(" + std::to_string(res) + "): "  + avro_strerror());
+      }
       const auto err = _array_reader.read(InputVarType{&element});
       if (err) {
         return err;
@@ -204,11 +214,19 @@ struct Reader {
   std::optional<Error> read_map(const MapReader& _map_reader,
                                 const InputMapType& _map) const noexcept {
     size_t size = 0;
-    avro_value_get_size(_map.val_, &size);
+    int res = avro_value_get_size(_map.val_, &size);
+    if(res!=0)
+    {
+      return Error(std::string(__FUNCTION__) + " error("+ std::to_string(res)+"): "  + avro_strerror());
+    }
     for (size_t ix = 0; ix < size; ++ix) {
       avro_value_t element;
       const char* key = nullptr;
-      avro_value_get_by_index(_map.val_, ix, &element, &key);
+      res = avro_value_get_by_index(_map.val_, ix, &element, &key);
+      if(res!=0)
+      {
+        return Error(std::string(__FUNCTION__) + " error("+ std::to_string(res)+"): "  + avro_strerror());
+      }
       _map_reader.read(std::string_view(key), InputVarType{&element});
     }
     return std::nullopt;
@@ -218,10 +236,18 @@ struct Reader {
   std::optional<Error> read_object(const ObjectReader& _object_reader,
                                    const InputObjectType& _obj) const noexcept {
     size_t size = 0;
-    avro_value_get_size(_obj.val_, &size);
+    int res = avro_value_get_size(_obj.val_, &size);
+    if(res!=0)
+    {
+      return Error(std::string(__FUNCTION__) + " error("+ std::to_string(res)+"): "  + avro_strerror());
+    }
     for (size_t ix = 0; ix < size; ++ix) {
       avro_value_t element;
-      avro_value_get_by_index(_obj.val_, ix, &element, nullptr);
+      res = avro_value_get_by_index(_obj.val_, ix, &element, nullptr);
+      if(res!=0)
+      {
+        return Error(std::string(__FUNCTION__) + " error("+ std::to_string(res)+"): "  + avro_strerror());
+      }
       _object_reader.read(static_cast<int>(ix), InputVarType{&element});
     }
     return std::nullopt;
diff --git a/include/rfl/avro/SchemaImpl.hpp b/include/rfl/avro/SchemaImpl.hpp
index 2f2fa50f..32293d55 100644
--- a/include/rfl/avro/SchemaImpl.hpp
+++ b/include/rfl/avro/SchemaImpl.hpp
@@ -5,8 +5,8 @@
 
 #include <string>
 
-#include "../Box.hpp"
-#include "../Result.hpp"
+//#include "../Box.hpp"
+//#include "../Result.hpp"
 
 namespace rfl::avro {
 
diff --git a/include/rfl/avro/Writer.hpp b/include/rfl/avro/Writer.hpp
index b530191d..0240918f 100644
--- a/include/rfl/avro/Writer.hpp
+++ b/include/rfl/avro/Writer.hpp
@@ -1,24 +1,17 @@
 #ifndef RFL_AVRO_WRITER_HPP_
 #define RFL_AVRO_WRITER_HPP_
 
-#include <avro.h>
-
-#include <bit>
 #include <cstdint>
-#include <exception>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <variant>
-#include <vector>
 
-#include "../Box.hpp"
+#include <avro.h>
+
+//#include "../Box.hpp"
 #include "../Bytestring.hpp"
-#include "../Ref.hpp"
-#include "../Result.hpp"
+//#include "../Ref.hpp"
+//#include "../Result.hpp"
 #include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 #include "../internal/is_literal.hpp"
@@ -63,94 +56,100 @@ class Writer {
 
   OutputObjectType object_as_root(const size_t _size) const noexcept;
 
-  OutputVarType null_as_root() const noexcept;
+  OutputVarType null_as_root() const;
 
   OutputUnionType union_as_root() const noexcept;
 
   template <class T>
-  OutputVarType value_as_root(const T& _var) const noexcept {
+  OutputVarType value_as_root(const T& _var) const {
     set_value(_var, root_);
     return OutputVarType{*root_};
   }
 
   OutputArrayType add_array_to_array(const size_t _size,
-                                     OutputArrayType* _parent) const noexcept;
+                                     OutputArrayType* _parent) const;
 
   OutputArrayType add_array_to_map(const std::string_view& _name,
                                    const size_t _size,
-                                   OutputMapType* _parent) const noexcept;
+                                   OutputMapType* _parent) const;
 
   OutputArrayType add_array_to_object(const std::string_view& _name,
                                       const size_t _size,
-                                      OutputObjectType* _parent) const noexcept;
+                                      OutputObjectType* _parent) const;
 
   OutputArrayType add_array_to_union(const size_t _index, const size_t _size,
-                                     OutputUnionType* _parent) const noexcept;
+                                     OutputUnionType* _parent) const;
 
   OutputMapType add_map_to_array(const size_t _size,
-                                 OutputArrayType* _parent) const noexcept;
+                                 OutputArrayType* _parent) const;
 
   OutputMapType add_map_to_map(const std::string_view& _name,
                                const size_t _size,
-                               OutputMapType* _parent) const noexcept;
+                               OutputMapType* _parent) const;
 
   OutputMapType add_map_to_object(const std::string_view& _name,
                                   const size_t _size,
-                                  OutputObjectType* _parent) const noexcept;
+                                  OutputObjectType* _parent) const;
 
   OutputMapType add_map_to_union(const size_t _index, const size_t _size,
-                                 OutputUnionType* _parent) const noexcept;
+                                 OutputUnionType* _parent) const;
 
   OutputObjectType add_object_to_array(const size_t _size,
-                                       OutputArrayType* _parent) const noexcept;
+                                       OutputArrayType* _parent) const;
 
   OutputObjectType add_object_to_map(const std::string_view& _name,
                                      const size_t _size,
-                                     OutputMapType* _parent) const noexcept;
+                                     OutputMapType* _parent) const;
 
   OutputObjectType add_object_to_object(
       const std::string_view& _name, const size_t _size,
-      OutputObjectType* _parent) const noexcept;
+      OutputObjectType* _parent) const;
 
   OutputObjectType add_object_to_union(const size_t _index, const size_t _size,
-                                       OutputUnionType* _parent) const noexcept;
+                                       OutputUnionType* _parent) const;
 
-  OutputUnionType add_union_to_array(OutputArrayType* _parent) const noexcept;
+  OutputUnionType add_union_to_array(OutputArrayType* _parent) const;
 
   OutputUnionType add_union_to_map(const std::string_view& _name,
-                                   OutputMapType* _parent) const noexcept;
+                                   OutputMapType* _parent) const;
 
   OutputUnionType add_union_to_object(const std::string_view& _name,
-                                      OutputObjectType* _parent) const noexcept;
+                                      OutputObjectType* _parent) const;
 
   OutputUnionType add_union_to_union(const size_t _index,
-                                     OutputUnionType* _parent) const noexcept;
+                                     OutputUnionType* _parent) const;
 
-  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept;
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const;
 
   OutputVarType add_null_to_map(const std::string_view& _name,
-                                OutputMapType* _parent) const noexcept;
+                                OutputMapType* _parent) const;
 
   OutputVarType add_null_to_object(const std::string_view& _name,
-                                   OutputObjectType* _parent) const noexcept;
+                                   OutputObjectType* _parent) const;
 
   OutputVarType add_null_to_union(const size_t _index,
-                                  OutputUnionType* _parent) const noexcept;
+                                  OutputUnionType* _parent) const;
 
   template <class T>
   OutputVarType add_value_to_array(const T& _var,
-                                   OutputArrayType* _parent) const noexcept {
+                                   OutputArrayType* _parent) const {
     avro_value_t new_value;
-    avro_value_append(&_parent->val_, &new_value, nullptr);
+    int result = avro_value_append(&_parent->val_, &new_value, nullptr);
+    if (result != 0) {
+      throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+    }
     set_value(_var, &new_value);
     return OutputVarType{new_value};
   }
 
   template <class T>
   OutputVarType add_value_to_map(const std::string_view& _name, const T& _var,
-                                 OutputMapType* _parent) const noexcept {
+                                 OutputMapType* _parent) const {
     avro_value_t new_value;
-    avro_value_add(&_parent->val_, _name.data(), &new_value, nullptr, nullptr);
+    int result = avro_value_add(&_parent->val_, _name.data(), &new_value, nullptr, nullptr);
+    if (result != 0) {
+      throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+    }
     set_value(_var, &new_value);
     return OutputVarType{new_value};
   }
@@ -158,54 +157,110 @@ class Writer {
   template <class T>
   OutputVarType add_value_to_object(const std::string_view& _name,
                                     const T& _var,
-                                    OutputObjectType* _parent) const noexcept {
+                                    OutputObjectType* _parent) const {
     avro_value_t new_value;
-    avro_value_get_by_name(&_parent->val_, _name.data(), &new_value, nullptr);
+    int result = avro_value_get_by_name(&_parent->val_, _name.data(), &new_value, nullptr);
+    if (result != 0) {
+      throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+    }
     set_value(_var, &new_value);
     return OutputVarType{new_value};
   }
 
   template <class T>
   OutputVarType add_value_to_union(const size_t _index, const T& _var,
-                                   OutputUnionType* _parent) const noexcept {
+                                   OutputUnionType* _parent) const {
+    if (_index > static_cast<size_t>(INT_MAX)) {
+      throw std::runtime_error(std::string(__FUNCTION__) + " index error");
+    }
     avro_value_t new_value;
-    avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_value);
+    int result = avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_value);
+    if (result != 0) {
+      throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+    }
     set_value(_var, &new_value);
     return OutputVarType{new_value};
   }
 
-  void end_array(OutputArrayType* _arr) const noexcept {}
+  void end_array(OutputArrayType* /*_arr*/) const noexcept {}
 
-  void end_map(OutputMapType* _obj) const noexcept {}
+  void end_map(OutputMapType* /*_obj*/) const noexcept {}
 
-  void end_object(OutputObjectType* _obj) const noexcept {}
+  void end_object(OutputObjectType* /*_obj*/) const noexcept {}
 
  private:
   template <class T>
-  void set_value(const T& _var, avro_value_t* _val) const noexcept {
-    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
-      avro_value_set_string_len(_val, _var.c_str(), _var.size() + 1);
+  void set_value(const T& _var, avro_value_t* _val) const {
+    std::cout << "[DEBUG] set_value called with type: " << typeid(T).name() << std::endl;
 
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      std::cout << "[DEBUG] Processing std::string: " << _var << std::endl;
+      int result = avro_value_set_string_len(_val, _var.c_str(), _var.size() + 1);
+      if (result != 0) {
+        std::cout << "[DEBUG] avro_value_set_string_len failed with result: " << result << std::endl;
+        throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+      }
     } else if constexpr (std::is_same<std::remove_cvref_t<T>,
                                       rfl::Bytestring>() ||
                          std::is_same<std::remove_cvref_t<T>,
                                       rfl::Vectorstring>()) {
       auto var = _var;
-      avro_value_set_bytes(_val, var.data(), var.size());
-
+      if (!var.data()) {
+        std::cout << "[DEBUG] Bytestring/Vectorstring has no data" << std::endl;
+        return;
+      }
+      std::cout << "[DEBUG] Processing Bytestring/Vectorstring of size: " << var.size() << std::endl;
+      int result = avro_value_set_bytes(_val, var.data(), var.size());
+      if (result != 0) {
+        std::cout << "[DEBUG] avro_value_set_bytes failed with result: " << result << std::endl;
+        throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+      }
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
-      avro_value_set_boolean(_val, _var);
-
+      std::cout << "[DEBUG] Processing bool: " << _var << std::endl;
+      int result = avro_value_set_boolean(_val, _var);
+      if (result != 0) {
+        std::cout << "[DEBUG] avro_value_set_boolean failed with result: " << result << std::endl;
+        throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+      }
     } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
-      avro_value_set_double(_val, static_cast<double>(_var));
-
+      std::cout << "[DEBUG] Processing floating point: " << _var << std::endl;
+      int result = avro_value_set_double(_val, static_cast<double>(_var));
+      if (result != 0) {
+        std::cout << "[DEBUG] avro_value_set_double failed with result: " << result << std::endl;
+        throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+      }
     } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
-      avro_value_set_long(_val, static_cast<std::int64_t>(_var));
-
+      std::cout << "[DEBUG] Processing integral: " << _var << std::endl;
+      int result = avro_value_set_long(_val, static_cast<std::int64_t>(_var));
+      if (result != 0) {
+        std::cout << "[DEBUG] avro_value_set_long failed with result: " << result << std::endl;
+        throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+      }
     } else if constexpr (internal::is_literal_v<T>) {
-      avro_value_set_enum(_val, static_cast<int>(_var.value()));
-
+      std::cout << "[DEBUG] Processing literal enum: " << static_cast<int>(_var.value()) << std::endl;
+      int result = avro_value_set_enum(_val, static_cast<int>(_var.value()));
+      if (result != 0) {
+        std::cout << "[DEBUG] avro_value_set_enum failed with result: " << result << std::endl;
+        throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+      }
+    } else if constexpr (internal::is_validator_v<T>) {
+      std::cout << "[DEBUG] Processing validator type" << std::endl;
+      // Для валидаторов используем внутреннее значение
+      using ValueType = std::remove_cvref_t<typename T::ReflectionType>;
+      const auto val = _var.value();
+      set_value<ValueType>(val, _val);
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, rfl::Timestamp<"%Y-%m-%d">>()) {
+      std::cout << "[DEBUG] Processing Timestamp" << std::endl;
+      // Конвертируем Timestamp в строку
+      const auto str = _var.to_string();
+      set_value<std::string>(str, _val);
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, rfl::Email>()) {
+      std::cout << "[DEBUG] Processing Email" << std::endl;
+      // Email является паттерном на базе std::string, используем внутреннее значение
+      const auto& str = static_cast<const std::string&>(_var);
+      set_value<std::string>(str, _val);
     } else {
+      std::cout << "[DEBUG] Unsupported type reached: " << typeid(T).name() << std::endl;
       static_assert(rfl::always_false_v<T>, "Unsupported type.");
     }
   }
diff --git a/include/rfl/avro/load.hpp b/include/rfl/avro/load.hpp
index b62ec2e2..8c0857e4 100644
--- a/include/rfl/avro/load.hpp
+++ b/include/rfl/avro/load.hpp
@@ -1,7 +1,7 @@
 #ifndef RFL_AVRO_LOAD_HPP_
 #define RFL_AVRO_LOAD_HPP_
 
-#include "../Processors.hpp"
+//#include "../Processors.hpp"
 #include "../Result.hpp"
 #include "../io/load_bytes.hpp"
 #include "read.hpp"
diff --git a/include/rfl/avro/read.hpp b/include/rfl/avro/read.hpp
index 673bbc4e..083268dc 100644
--- a/include/rfl/avro/read.hpp
+++ b/include/rfl/avro/read.hpp
@@ -3,7 +3,6 @@
 
 #include <avro.h>
 
-#include <bit>
 #include <istream>
 #include <string>
 #include <type_traits>
@@ -37,16 +36,20 @@ Result<internal::wrap_in_rfl_array_t<T>> read(
   avro_reader_t avro_reader =
       avro_reader_memory(internal::ptr_cast<const char*>(_bytes), _size);
   avro_value_t root;
-  avro_generic_value_new(_schema.iface(), &root);
-  auto err = avro_value_read(avro_reader, &root);
-  if (err) {
+  int res = avro_generic_value_new(_schema.iface(), &root);
+  if (res != 0) {
     avro_value_decref(&root);
+    return error(std::string("Could not read root value: ") + avro_strerror());
+  }
+  res = avro_value_read(avro_reader, &root);
+  if (res) {
     avro_reader_free(avro_reader);
+    avro_value_decref(&root);
     return error(std::string("Could not read root value: ") + avro_strerror());
   }
   auto result = read<T, Ps...>(InputVarType{&root});
-  avro_value_decref(&root);
   avro_reader_free(avro_reader);
+  avro_value_decref(&root);
   return result;
 }
 
diff --git a/include/rfl/avro/schema/Type.hpp b/include/rfl/avro/schema/Type.hpp
index d44f3589..512421ab 100644
--- a/include/rfl/avro/schema/Type.hpp
+++ b/include/rfl/avro/schema/Type.hpp
@@ -2,12 +2,11 @@
 #define RFL_AVRO_SCHEMA_TYPE_HPP_
 
 #include <map>
-#include <memory>
 #include <optional>
 #include <string>
 
 #include "../../Literal.hpp"
-#include "../../Object.hpp"
+//#include "../../Object.hpp"
 #include "../../Ref.hpp"
 #include "../../Rename.hpp"
 #include "../../Variant.hpp"
@@ -16,69 +15,69 @@ namespace rfl::avro::schema {
 
 struct Type {
   struct Null {
-    Literal<"null"> type;
+    Literal<"null"> type{};
   };
 
   struct Boolean {
-    Literal<"boolean"> type;
+    Literal<"boolean"> type{};
   };
 
   struct Int {
-    Literal<"int"> type;
+    Literal<"int"> type{};
   };
 
   struct Long {
-    Literal<"long"> type;
+    Literal<"long"> type{};
   };
 
   struct Float {
-    Literal<"float"> type;
+    Literal<"float"> type{};
   };
 
   struct Double {
-    Literal<"float"> type;
+    Literal<"float"> type{};
   };
 
   struct Bytes {
-    Literal<"bytes"> type;
+    Literal<"bytes"> type{};
   };
 
   struct String {
-    Literal<"string"> type;
+    Literal<"string"> type{};
   };
 
   struct RecordField {
-    std::string name;
-    rfl::Ref<Type> type;
+    std::string name{};
+    rfl::Ref<Type> type{};
   };
 
   struct Record {
-    Literal<"record"> type;
-    std::string name;
-    std::vector<RecordField> fields;
-    std::optional<std::string> doc;
+    Literal<"record"> type{};
+    std::string name{};
+    std::vector<RecordField> fields{};
+    std::optional<std::string> doc{};
   };
 
   struct Enum {
-    Literal<"enum"> type;
-    std::string name;
-    std::vector<std::string> symbols;
+    Literal<"enum"> type{};
+    std::string name{};
+    std::vector<std::string> symbols{};
   };
 
   struct Array {
-    Literal<"array"> type;
-    rfl::Ref<Type> items;
-    Rename<"default", std::vector<std::string>> default_;
+    Literal<"array"> type{};
+    rfl::Ref<Type> items{};
+    Rename<"default", std::vector<std::string>> default_{};
   };
 
   struct Map {
-    Literal<"map"> type;
-    rfl::Ref<Type> values;
-    Rename<"default", std::map<std::string, std::string>> default_;
+    Literal<"map"> type{};
+    rfl::Ref<Type> values{};
+    Rename<"default", std::map<std::string, std::string>> default_{};
   };
 
   struct Reference {
-    std::string type;
+    std::string type{};
   };
 
   using ReflectionType =
diff --git a/include/rfl/avro/to_schema.hpp b/include/rfl/avro/to_schema.hpp
index 1eb04dfb..fe9b82a2 100644
--- a/include/rfl/avro/to_schema.hpp
+++ b/include/rfl/avro/to_schema.hpp
@@ -1,21 +1,19 @@
 #ifndef RFL_AVRO_TOSCHEMA_HPP_
 #define RFL_AVRO_TOSCHEMA_HPP_
 
-#include <map>
 #include <string>
-#include <type_traits>
 
-#include "../Literal.hpp"
+//#include "../Literal.hpp"
 #include "../Processors.hpp"
-#include "../Variant.hpp"
-#include "../json.hpp"
-#include "../parsing/schema/Type.hpp"
-#include "../parsing/schema/ValidationType.hpp"
+//#include "../Variant.hpp"
+//#include "../json.hpp"
+//#include "../parsing/schema/Type.hpp"
+//#include "../parsing/schema/ValidationType.hpp"
 #include "../parsing/schema/make.hpp"
 #include "Reader.hpp"
 #include "Schema.hpp"
 #include "Writer.hpp"
-#include "schema/Type.hpp"
+//#include "schema/Type.hpp"
 
 namespace rfl::avro {
 
diff --git a/include/rfl/avro/write.hpp b/include/rfl/avro/write.hpp
index 2ae7dfab..1646a21a 100644
--- a/include/rfl/avro/write.hpp
+++ b/include/rfl/avro/write.hpp
@@ -3,17 +3,12 @@
 
 #include <avro.h>
 
-#include <bit>
-#include <cstdint>
 #include <ostream>
-#include <sstream>
-#include <string>
 #include <type_traits>
-#include <utility>
 
 #include "../parsing/Parent.hpp"
 #include "Parser.hpp"
-#include "Schema.hpp"
+//#include "Schema.hpp"
 #include "Writer.hpp"
 #include "to_schema.hpp"
 
@@ -21,22 +16,31 @@ namespace rfl::avro {
 
 /// Returns AVRO bytes.
 template <class... Ps>
-std::vector<char> write(const auto& _obj, const auto& _schema) noexcept {
+std::vector<char> write(const auto& _obj, const auto& _schema) {
   using T = std::remove_cvref_t<decltype(_obj)>;
   using U = typename std::remove_cvref_t<decltype(_schema)>::Type;
   using ParentType = parsing::Parent<Writer>;
   static_assert(std::is_same<T, U>(),
                 "The schema must be compatible with the type to write.");
   avro_value_t root;
-  avro_generic_value_new(_schema.iface(), &root);
-  const auto writer = Writer(&root);
+  int result = avro_generic_value_new(_schema.iface(), &root);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
+const auto writer = Writer(&root);
   Parser<T, Processors<Ps...>>::write(writer, _obj,
                                       typename ParentType::Root{});
   size_t size = 0;
-  avro_value_sizeof(&root, &size);
+  result = avro_value_sizeof(&root, &size);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   std::vector<char> buffer(size);
   avro_writer_t avro_writer = avro_writer_memory(buffer.data(), buffer.size());
-  avro_value_write(avro_writer, &root);
+  result = avro_value_write(avro_writer, &root);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   avro_value_decref(&root);
   avro_writer_free(avro_writer);
   return buffer;
diff --git a/include/rfl/bson/Parser.hpp b/include/rfl/bson/Parser.hpp
index df7294a9..8f132943 100644
--- a/include/rfl/bson/Parser.hpp
+++ b/include/rfl/bson/Parser.hpp
@@ -3,7 +3,7 @@
 
 #include <bson/bson.h>
 
-#include "../parsing/Parser.hpp"
+//#include "../parsing/Parser.hpp"
 #include "Reader.hpp"
 #include "Writer.hpp"
 
diff --git a/include/rfl/bson/Reader.hpp b/include/rfl/bson/Reader.hpp
index d7736bef..e8abc5af 100644
--- a/include/rfl/bson/Reader.hpp
+++ b/include/rfl/bson/Reader.hpp
@@ -3,27 +3,18 @@
 
 #include <bson/bson.h>
 
-#include <array>
-#include <concepts>
 #include <cstddef>
 #include <exception>
-#include <map>
-#include <memory>
 #include <optional>
-#include <sstream>
-#include <stdexcept>
 #include <string>
-#include <string_view>
 #include <type_traits>
-#include <unordered_map>
-#include <vector>
 
-#include "../Box.hpp"
-#include "../Bytestring.hpp"
+//#include "../Box.hpp"
+//#include "../Bytestring.hpp"
 #include "../Result.hpp"
-#include "../Vectorstring.hpp"
+//#include "../Vectorstring.hpp"
 #include "../always_false.hpp"
-#include "../internal/ptr_cast.hpp"
+//#include "../internal/ptr_cast.hpp"
 
 namespace rfl {
 namespace bson {
diff --git a/include/rfl/bson/Writer.hpp b/include/rfl/bson/Writer.hpp
index c120350c..326857ff 100644
--- a/include/rfl/bson/Writer.hpp
+++ b/include/rfl/bson/Writer.hpp
@@ -4,10 +4,6 @@
 #include <bson/bson.h>
 
 #include <cstddef>
-#include <exception>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -17,7 +13,7 @@
 #include "../Box.hpp"
 #include "../Bytestring.hpp"
 #include "../Ref.hpp"
-#include "../Result.hpp"
+//#include "../Result.hpp"
 #include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 #include "../internal/ptr_cast.hpp"
diff --git a/include/rfl/bson/read.hpp b/include/rfl/bson/read.hpp
index 04ca463d..a18204d3 100644
--- a/include/rfl/bson/read.hpp
+++ b/include/rfl/bson/read.hpp
@@ -4,7 +4,6 @@
 #include <bson/bson.h>
 
 #include <istream>
-#include <string>
 
 #include "../Processors.hpp"
 #include "../concepts.hpp"
diff --git a/include/rfl/bson/save.hpp b/include/rfl/bson/save.hpp
index 3ebbedad..1f4202c6 100644
--- a/include/rfl/bson/save.hpp
+++ b/include/rfl/bson/save.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_BSON_SAVE_HPP_
 #define RFL_BSON_SAVE_HPP_
 
-#include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/bson/write.hpp b/include/rfl/bson/write.hpp
index 86b2d2ff..845a4d13 100644
--- a/include/rfl/bson/write.hpp
+++ b/include/rfl/bson/write.hpp
@@ -4,8 +4,6 @@
 #include <bson/bson.h>
 
 #include <ostream>
-#include <sstream>
-#include <string>
 #include <utility>
 
 #include "../Processors.hpp"
diff --git a/include/rfl/capnproto/Parser.hpp b/include/rfl/capnproto/Parser.hpp
index 3a966336..43e9ed73 100644
--- a/include/rfl/capnproto/Parser.hpp
+++ b/include/rfl/capnproto/Parser.hpp
@@ -1,10 +1,10 @@
 #ifndef RFL_CAPNPROTO_PARSER_HPP_
 #define RFL_CAPNPROTO_PARSER_HPP_
 
-#include "../Generic.hpp"
+//#include "../Generic.hpp"
 #include "../Tuple.hpp"
 #include "../always_false.hpp"
-#include "../parsing/Parser.hpp"
+//#include "../parsing/Parser.hpp"
 #include "Reader.hpp"
 #include "Writer.hpp"
 
@@ -91,16 +91,16 @@ struct Parser<capnproto::Reader, capnproto::Writer,
   }
 
   template <class P>
-  static void write(const W& _w,
+  static void write(const W& /*_w*/,
                     const internal::Skip<T, _skip_serialization,
-                                         _skip_deserialization>& _skip,
-                    const P& _parent) noexcept {
+                                         _skip_deserialization>& /*_skip*/,
+                    const P& /*_parent*/) noexcept {
     static_assert(always_false_v<P>,
                   "rfl::Skip is unsupported in Cap'n Proto.");
   }
 
   template <class U>
-  static schema::Type to_schema(U* _definitions) {
+  static schema::Type to_schema(U* /*_definitions*/) {
     static_assert(always_false_v<U>,
                   "rfl::Skip is unsupported in Cap'n Proto.");
     return schema::Type{};
diff --git a/include/rfl/capnproto/Reader.hpp b/include/rfl/capnproto/Reader.hpp
index 7d3a74f4..8613a8ce 100644
--- a/include/rfl/capnproto/Reader.hpp
+++ b/include/rfl/capnproto/Reader.hpp
@@ -3,12 +3,9 @@
 
 #include <capnp/dynamic.h>
 
-#include <cstddef>
 #include <exception>
 #include <string>
-#include <string_view>
 #include <type_traits>
-#include <vector>
 
 #include "../Bytestring.hpp"
 #include "../Result.hpp"
diff --git a/include/rfl/capnproto/SchemaImpl.hpp b/include/rfl/capnproto/SchemaImpl.hpp
index 090d7e01..74716b3d 100644
--- a/include/rfl/capnproto/SchemaImpl.hpp
+++ b/include/rfl/capnproto/SchemaImpl.hpp
@@ -3,11 +3,10 @@
 
 #include <capnp/schema-parser.h>
 
-#include <memory>
 #include <string>
 
-#include "../Box.hpp"
-#include "../Result.hpp"
+//#include "../Box.hpp"
+//#include "../Result.hpp"
 
 namespace rfl::capnproto {
 
diff --git a/include/rfl/capnproto/Writer.hpp b/include/rfl/capnproto/Writer.hpp
index 7d7f0e31..701d2d29 100644
--- a/include/rfl/capnproto/Writer.hpp
+++ b/include/rfl/capnproto/Writer.hpp
@@ -4,26 +4,20 @@
 #include <capnp/dynamic.h>
 #include <kj/array.h>
 
-#include <bit>
 #include <cstdint>
-#include <exception>
-#include <map>
-#include <sstream>
 #include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <variant>
-#include <vector>
 
-#include "../Box.hpp"
+//#include "../Box.hpp"
 #include "../Bytestring.hpp"
-#include "../Ref.hpp"
-#include "../Result.hpp"
+//#include "../Ref.hpp"
+//#include "../Result.hpp"
 #include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 #include "../internal/is_literal.hpp"
-#include "../internal/ptr_cast.hpp"
+//#include "../internal/ptr_cast.hpp"
 
 namespace rfl::capnproto {
 
@@ -62,14 +56,14 @@ class Writer {
   ~Writer();
 
   template <class T>
-  OutputArrayType array_as_root(const T _size) const noexcept {
+  OutputArrayType array_as_root(const T /*_size*/) const noexcept {
     static_assert(always_false_v<T>,
                   "In Cap'n Proto, root values must always be structs.");
     throw std::runtime_error("Unsupported.");
   }
 
   template <class T>
-  OutputMapType map_as_root(const T _size) const noexcept {
+  OutputMapType map_as_root(const T /*_size*/) const noexcept {
     static_assert(always_false_v<T>,
                   "In Cap'n Proto, root values must always be structs.");
     throw std::runtime_error("Unsupported.");
@@ -92,7 +86,7 @@ class Writer {
   }
 
   template <class T>
-  OutputVarType value_as_root(const T& _var) const noexcept {
+  OutputVarType value_as_root(const T& /*_var*/) const noexcept {
     static_assert(always_false_v<T>,
                   "In Cap'n Proto, root values must always be structs.");
     throw std::runtime_error("Unsupported.");
@@ -261,11 +255,11 @@ class Writer {
     return OutputVarType{};
   }
 
-  void end_array(OutputArrayType* _arr) const noexcept {}
+  void end_array(OutputArrayType* /*_arr*/) const noexcept {}
 
-  void end_map(OutputMapType* _obj) const noexcept {}
+  void end_map(OutputMapType* /*_obj*/) const noexcept {}
 
-  void end_object(OutputObjectType* _obj) const noexcept {}
+  void end_object(OutputObjectType* /*_obj*/) const noexcept {}
 
  private:
   capnp::DynamicStruct::Builder* root_;
diff --git a/include/rfl/capnproto/load.hpp b/include/rfl/capnproto/load.hpp
index e40c0d96..481c9288 100644
--- a/include/rfl/capnproto/load.hpp
+++ b/include/rfl/capnproto/load.hpp
@@ -1,7 +1,7 @@
 #ifndef RFL_CAPNPROTO_LOAD_HPP_
 #define RFL_CAPNPROTO_LOAD_HPP_
 
-#include "../Processors.hpp"
+//#include "../Processors.hpp"
 #include "../Result.hpp"
 #include "../io/load_bytes.hpp"
 #include "read.hpp"
diff --git a/include/rfl/capnproto/read.hpp b/include/rfl/capnproto/read.hpp
index f209603b..74e38824 100644
--- a/include/rfl/capnproto/read.hpp
+++ b/include/rfl/capnproto/read.hpp
@@ -5,16 +5,14 @@
 #include <capnp/serialize-packed.h>
 #include <kj/io.h>
 
-#include <bit>
 #include <istream>
-#include <string>
 #include <type_traits>
 
 #include "../Processors.hpp"
 #include "../SnakeCaseToCamelCase.hpp"
 #include "../concepts.hpp"
-#include "../internal/ptr_cast.hpp"
-#include "../internal/strings/strings.hpp"
+//#include "../internal/ptr_cast.hpp"
+//#include "../internal/strings/strings.hpp"
 #include "../internal/wrap_in_rfl_array_t.hpp"
 #include "Parser.hpp"
 #include "Reader.hpp"
diff --git a/include/rfl/capnproto/save.hpp b/include/rfl/capnproto/save.hpp
index 2f4afe0f..c2d9e3c0 100644
--- a/include/rfl/capnproto/save.hpp
+++ b/include/rfl/capnproto/save.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_CAPNPROTO_SAVE_HPP_
 #define RFL_CAPNPROTO_SAVE_HPP_
 
-#include <fstream>
 #include <iostream>
 #include <string>
 
diff --git a/include/rfl/capnproto/schema/Type.hpp b/include/rfl/capnproto/schema/Type.hpp
index ed4814c4..1bbc0f7d 100644
--- a/include/rfl/capnproto/schema/Type.hpp
+++ b/include/rfl/capnproto/schema/Type.hpp
@@ -2,15 +2,12 @@
 #define RFL_CAPNPROTO_SCHEMA_TYPE_HPP_
 
 #include <iostream>
-#include <map>
-#include <memory>
-#include <optional>
 #include <string>
 
-#include "../../Literal.hpp"
-#include "../../Object.hpp"
+//#include "../../Literal.hpp"
+//#include "../../Object.hpp"
 #include "../../Ref.hpp"
-#include "../../Rename.hpp"
+//#include "../../Rename.hpp"
 #include "../../Variant.hpp"
 
 namespace rfl::capnproto::schema {
@@ -45,30 +42,30 @@ struct Type {
   struct Text {};
 
   struct Enum {
-    std::string name;
-    std::vector<std::string> fields;
+    std::string name{};
+    std::vector<std::string> fields{};
   };
 
   struct List {
-    rfl::Ref<Type> type;
+    rfl::Ref<Type> type{};
   };
 
   struct Map {
-    rfl::Ref<Type> type;
+    rfl::Ref<Type> type{};
   };
 
   struct Reference {
-    std::string type_name;
+    std::string type_name{};
   };
 
   struct Struct {
-    std::string name;
-    std::vector<std::pair<std::string, Type>> fields;
+    std::string name{};
+    std::vector<std::pair<std::string, Type>> fields{};
   };
 
   struct Union {
-    std::string name;
-    std::vector<std::pair<std::string, Type>> fields;
+    std::string name{};
+    std::vector<std::pair<std::string, Type>> fields{};
   };
 
   using ReflectionType =
diff --git a/include/rfl/capnproto/to_schema.hpp b/include/rfl/capnproto/to_schema.hpp
index 24d66448..f4dd3ae1 100644
--- a/include/rfl/capnproto/to_schema.hpp
+++ b/include/rfl/capnproto/to_schema.hpp
@@ -1,22 +1,21 @@
 #ifndef RFL_CAPNPROTO_TOSCHEMA_HPP_
 #define RFL_CAPNPROTO_TOSCHEMA_HPP_
 
-#include <map>
 #include <string>
-#include <type_traits>
 
-#include "../Literal.hpp"
-#include "../Processors.hpp"
+//#include "../Literal.hpp"
+//#include "../Processors.hpp"
 #include "../Result.hpp"
-#include "../SnakeCaseToCamelCase.hpp"
-#include "../Variant.hpp"
-#include "../json.hpp"
-#include "../parsing/schema/Type.hpp"
-#include "../parsing/schema/ValidationType.hpp"
+//#include "../SnakeCaseToCamelCase.hpp"
+//#include "../Variant.hpp"
+//#include "../json.hpp"
+//#include "../parsing/schema/Type.hpp"
+//#include "../parsing/schema/ValidationType.hpp"
 #include "../parsing/schema/make.hpp"
 #include "Schema.hpp"
 #include "Writer.hpp"
-#include "schema/Type.hpp"
+#include "Reader.hpp"
+//#include "schema/Type.hpp"
 
 namespace rfl::capnproto {
 
diff --git a/include/rfl/capnproto/write.hpp b/include/rfl/capnproto/write.hpp
index 3ce04530..c2badb38 100644
--- a/include/rfl/capnproto/write.hpp
+++ b/include/rfl/capnproto/write.hpp
@@ -8,20 +8,15 @@
 #include <capnp/serialize-packed.h>
 #include <kj/io.h>
 
-#include <bit>
-#include <cstdint>
 #include <ostream>
-#include <sstream>
-#include <string>
 #include <type_traits>
-#include <utility>
 
 #include "../SnakeCaseToCamelCase.hpp"
 #include "../internal/ptr_cast.hpp"
-#include "../internal/strings/strings.hpp"
+//#include "../internal/strings/strings.hpp"
 #include "../parsing/Parent.hpp"
 #include "Parser.hpp"
-#include "Schema.hpp"
+//#include "Schema.hpp"
 #include "Writer.hpp"
 #include "get_root_name.hpp"
 #include "to_schema.hpp"
diff --git a/include/rfl/cbor/Parser.hpp b/include/rfl/cbor/Parser.hpp
index 594a236b..658190bf 100644
--- a/include/rfl/cbor/Parser.hpp
+++ b/include/rfl/cbor/Parser.hpp
@@ -1,8 +1,8 @@
 #ifndef RFL_CBOR_PARSER_HPP_
 #define RFL_CBOR_PARSER_HPP_
 
-#include "../Tuple.hpp"
-#include "../parsing/Parser.hpp"
+//#include "../Tuple.hpp"
+//#include "../parsing/Parser.hpp"
 #include "Reader.hpp"
 #include "Writer.hpp"
 
diff --git a/include/rfl/cbor/Reader.hpp b/include/rfl/cbor/Reader.hpp
index 3672c974..59092fe5 100644
--- a/include/rfl/cbor/Reader.hpp
+++ b/include/rfl/cbor/Reader.hpp
@@ -5,7 +5,6 @@
 #include <exception>
 #include <jsoncons/json.hpp>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <vector>
 
diff --git a/include/rfl/cbor/Writer.hpp b/include/rfl/cbor/Writer.hpp
index 28ef5d4b..02b1c75d 100644
--- a/include/rfl/cbor/Writer.hpp
+++ b/include/rfl/cbor/Writer.hpp
@@ -1,22 +1,15 @@
 #ifndef RFL_CBOR_WRITER_HPP_
 #define RFL_CBOR_WRITER_HPP_
 
-#include <bit>
-#include <exception>
 #include <jsoncons_ext/cbor/cbor_encoder.hpp>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <variant>
-#include <vector>
 
-#include "../Box.hpp"
+//#include "../Box.hpp"
 #include "../Bytestring.hpp"
-#include "../Ref.hpp"
-#include "../Result.hpp"
+//#include "../Ref.hpp"
+//#include "../Result.hpp"
 #include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 
@@ -67,14 +60,14 @@ class Writer {
 
   template <class T>
   OutputVarType add_value_to_array(const T& _var,
-                                   OutputArrayType* _parent) const noexcept {
+                                   OutputArrayType* /*_parent*/) const noexcept {
     return new_value(_var);
   }
 
   template <class T>
   OutputVarType add_value_to_object(const std::string_view& _name,
                                     const T& _var,
-                                    OutputObjectType* _parent) const noexcept {
+                                    OutputObjectType* /*_parent*/) const noexcept {
     encoder_->key(_name);
     return new_value(_var);
   }
diff --git a/include/rfl/cbor/load.hpp b/include/rfl/cbor/load.hpp
index eccd4f43..f4979248 100644
--- a/include/rfl/cbor/load.hpp
+++ b/include/rfl/cbor/load.hpp
@@ -1,7 +1,7 @@
 #ifndef RFL_CBOR_LOAD_HPP_
 #define RFL_CBOR_LOAD_HPP_
 
-#include "../Processors.hpp"
+//#include "../Processors.hpp"
 #include "../Result.hpp"
 #include "../io/load_bytes.hpp"
 #include "read.hpp"
diff --git a/include/rfl/cbor/read.hpp b/include/rfl/cbor/read.hpp
index 12b4508e..9e8247ad 100644
--- a/include/rfl/cbor/read.hpp
+++ b/include/rfl/cbor/read.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_CBOR_READ_HPP_
 #define RFL_CBOR_READ_HPP_
 
-#include <bit>
 #include <istream>
 #include <jsoncons/json.hpp>
 #include <jsoncons_ext/cbor/decode_cbor.hpp>
diff --git a/include/rfl/cbor/save.hpp b/include/rfl/cbor/save.hpp
index efa9ccac..97f0961f 100644
--- a/include/rfl/cbor/save.hpp
+++ b/include/rfl/cbor/save.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_CBOR_SAVE_HPP_
 #define RFL_CBOR_SAVE_HPP_
 
-#include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/cbor/write.hpp b/include/rfl/cbor/write.hpp
index ae9f8f86..fad76876 100644
--- a/include/rfl/cbor/write.hpp
+++ b/include/rfl/cbor/write.hpp
@@ -4,9 +4,6 @@
 #include <cstdint>
 #include <jsoncons_ext/cbor/cbor_encoder.hpp>
 #include <ostream>
-#include <sstream>
-#include <string>
-#include <utility>
 
 #include "../internal/ptr_cast.hpp"
 #include "../parsing/Parent.hpp"
diff --git a/include/rfl/csv/read.hpp b/include/rfl/csv/read.hpp
index 178382f5..58d9f629 100644
--- a/include/rfl/csv/read.hpp
+++ b/include/rfl/csv/read.hpp
@@ -5,13 +5,12 @@
 #include <arrow/io/api.h>
 
 #include <istream>
-#include <memory>
 #include <string>
 #include <string_view>
 
-#include "../Processors.hpp"
+//#include "../Processors.hpp"
 #include "../Result.hpp"
-#include "../concepts.hpp"
+//#include "../concepts.hpp"
 #include "../internal/wrap_in_rfl_array_t.hpp"
 #include "../parsing/tabular/ArrowReader.hpp"
 #include "Settings.hpp"
diff --git a/include/rfl/csv/save.hpp b/include/rfl/csv/save.hpp
index 56dcd928..3cc5709d 100644
--- a/include/rfl/csv/save.hpp
+++ b/include/rfl/csv/save.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_CSV_SAVE_HPP_
 #define RFL_CSV_SAVE_HPP_
 
-#include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/csv/write.hpp b/include/rfl/csv/write.hpp
index 6f9bd931..ed47d9c9 100644
--- a/include/rfl/csv/write.hpp
+++ b/include/rfl/csv/write.hpp
@@ -5,16 +5,13 @@
 #include <arrow/csv/writer.h>
 #include <arrow/io/api.h>
 
-#include <cstdint>
 #include <ostream>
-#include <sstream>
 #include <stdexcept>
 #include <string>
 #include <string_view>
-#include <utility>
 
-#include "../Processors.hpp"
-#include "../Ref.hpp"
+//#include "../Processors.hpp"
+//#include "../Ref.hpp"
 #include "../parsing/tabular/ArrowWriter.hpp"
 #include "Settings.hpp"
 
diff --git a/include/rfl/flexbuf/Reader.hpp b/include/rfl/flexbuf/Reader.hpp
index 8772be56..d8d8460f 100644
--- a/include/rfl/flexbuf/Reader.hpp
+++ b/include/rfl/flexbuf/Reader.hpp
@@ -5,19 +5,15 @@
 
 #include <cstddef>
 #include <exception>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <vector>
 
-#include "../Bytestring.hpp"
+//#include "../Bytestring.hpp"
 #include "../Result.hpp"
-#include "../Vectorstring.hpp"
+//#include "../Vectorstring.hpp"
 #include "../always_false.hpp"
-#include "../internal/ptr_cast.hpp"
+//#include "../internal/ptr_cast.hpp"
 
 namespace rfl {
 namespace flexbuf {
diff --git a/include/rfl/flexbuf/Writer.hpp b/include/rfl/flexbuf/Writer.hpp
index 9f5f4703..2d254f7e 100644
--- a/include/rfl/flexbuf/Writer.hpp
+++ b/include/rfl/flexbuf/Writer.hpp
@@ -4,20 +4,13 @@
 #include <flatbuffers/flexbuffers.h>
 
 #include <cstddef>
-#include <exception>
-#include <functional>
-#include <map>
-#include <optional>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <vector>
 
 #include "../Bytestring.hpp"
-#include "../Ref.hpp"
-#include "../Result.hpp"
+//#include "../Ref.hpp"
+//#include "../Result.hpp"
 #include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 
@@ -70,14 +63,14 @@ struct Writer {
 
   template <class T>
   OutputVarType add_value_to_array(const T& _var,
-                                   OutputArrayType* _parent) const noexcept {
+                                   OutputArrayType* /*_parent*/) const noexcept {
     return insert_value(_var);
   }
 
   template <class T>
   OutputVarType add_value_to_object(const std::string_view& _name,
                                     const T& _var,
-                                    OutputObjectType* _parent) const noexcept {
+                                    OutputObjectType* /*_parent*/) const noexcept {
     return insert_value(_name, _var);
   }
 
diff --git a/include/rfl/flexbuf/read.hpp b/include/rfl/flexbuf/read.hpp
index fa24b7c1..4a87952c 100644
--- a/include/rfl/flexbuf/read.hpp
+++ b/include/rfl/flexbuf/read.hpp
@@ -7,9 +7,9 @@
 #include <vector>
 
 #include "../Processors.hpp"
-#include "../Result.hpp"
+//#include "../Result.hpp"
 #include "../concepts.hpp"
-#include "../internal/ptr_cast.hpp"
+//#include "../internal/ptr_cast.hpp"
 #include "Parser.hpp"
 
 namespace rfl {
diff --git a/include/rfl/flexbuf/save.hpp b/include/rfl/flexbuf/save.hpp
index cc2a8d24..9cd0a645 100644
--- a/include/rfl/flexbuf/save.hpp
+++ b/include/rfl/flexbuf/save.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_FLEXBUF_SAVE_HPP_
 #define RFL_FLEXBUF_SAVE_HPP_
 
-#include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/flexbuf/write.hpp b/include/rfl/flexbuf/write.hpp
index 48ba4217..aa52d18c 100644
--- a/include/rfl/flexbuf/write.hpp
+++ b/include/rfl/flexbuf/write.hpp
@@ -3,13 +3,11 @@
 
 #include <flatbuffers/flexbuffers.h>
 
-#include <cstddef>
 #include <ostream>
-#include <sstream>
 #include <vector>
 
 #include "../Processors.hpp"
-#include "../Ref.hpp"
+//#include "../Ref.hpp"
 #include "../internal/ptr_cast.hpp"
 #include "../parsing/Parent.hpp"
 #include "Parser.hpp"
diff --git a/include/rfl/generic/Reader.hpp b/include/rfl/generic/Reader.hpp
index df5e7c4c..27920825 100644
--- a/include/rfl/generic/Reader.hpp
+++ b/include/rfl/generic/Reader.hpp
@@ -2,14 +2,9 @@
 #define GENERIC_READER_HPP_
 
 #include <cstddef>
-#include <exception>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <vector>
 
 #include "../Generic.hpp"
 #include "../Result.hpp"
@@ -97,7 +92,7 @@ struct Reader {
 
   template <class T>
   rfl::Result<T> use_custom_constructor(
-      const InputVarType _var) const noexcept {
+      const InputVarType /*_var*/) const noexcept {
     return error("Not supported for generic types");
   }
 };
diff --git a/include/rfl/generic/Writer.hpp b/include/rfl/generic/Writer.hpp
index d97c05aa..4d8c51ca 100644
--- a/include/rfl/generic/Writer.hpp
+++ b/include/rfl/generic/Writer.hpp
@@ -2,20 +2,12 @@
 #define GENERIC_WRITER_HPP_
 
 #include <cstddef>
-#include <exception>
-#include <functional>
-#include <map>
-#include <optional>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <vector>
 
 #include "../Generic.hpp"
-#include "../Result.hpp"
-#include "../Variant.hpp"
 #include "../always_false.hpp"
 
 namespace rfl::generic {
diff --git a/include/rfl/generic/read.hpp b/include/rfl/generic/read.hpp
index 2a0e61a4..0934c8c3 100644
--- a/include/rfl/generic/read.hpp
+++ b/include/rfl/generic/read.hpp
@@ -1,12 +1,9 @@
 #ifndef GENERIC_READ_HPP_
 #define GENERIC_READ_HPP_
 
-#include <istream>
-#include <vector>
 
 #include "../Generic.hpp"
 #include "../Processors.hpp"
-#include "../Result.hpp"
 #include "Parser.hpp"
 
 namespace rfl {
diff --git a/include/rfl/generic/write.hpp b/include/rfl/generic/write.hpp
index f2019ca0..401c6927 100644
--- a/include/rfl/generic/write.hpp
+++ b/include/rfl/generic/write.hpp
@@ -1,11 +1,6 @@
 #ifndef GENERIC_WRITE_HPP_
 #define GENERIC_WRITE_HPP_
 
-#include <cstddef>
-#include <ostream>
-#include <sstream>
-#include <vector>
-
 #include "../Generic.hpp"
 #include "../parsing/Parent.hpp"
 #include "Parser.hpp"
diff --git a/include/rfl/internal/Array.hpp b/include/rfl/internal/Array.hpp
index a84c1951..e61ef76d 100644
--- a/include/rfl/internal/Array.hpp
+++ b/include/rfl/internal/Array.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_ARRAY_HPP_
 #define RFL_INTERNAL_ARRAY_HPP_
 
-#include <array>
-#include <cstddef>
 #include <type_traits>
 
 #include "to_std_array.hpp"
diff --git a/include/rfl/internal/Field.hpp b/include/rfl/internal/Field.hpp
index 4a3f9b30..186b12f0 100644
--- a/include/rfl/internal/Field.hpp
+++ b/include/rfl/internal/Field.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_FIELD_TUPLE_T_HPP_
 #define RFL_INTERNAL_FIELD_TUPLE_T_HPP_
 
-#include <functional>
-#include <tuple>
 #include <type_traits>
 
 #include "copy_to_field_tuple.hpp"
diff --git a/include/rfl/internal/Getter.hpp b/include/rfl/internal/Getter.hpp
index 8d160eb2..d64aae4e 100644
--- a/include/rfl/internal/Getter.hpp
+++ b/include/rfl/internal/Getter.hpp
@@ -1,9 +1,6 @@
 #ifndef RFL_INTERNAL_GETTER_HPP_
 #define RFL_INTERNAL_GETTER_HPP_
 
-#include <tuple>
-#include <variant>
-
 #include "../Tuple.hpp"
 #include "StringLiteral.hpp"
 #include "find_index.hpp"
diff --git a/include/rfl/internal/HasValidation.hpp b/include/rfl/internal/HasValidation.hpp
index da2b4550..23391c30 100644
--- a/include/rfl/internal/HasValidation.hpp
+++ b/include/rfl/internal/HasValidation.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_HASVALIDATION_HPP_
 #define RFL_INTERNAL_HASVALIDATION_HPP_
 
-#include <type_traits>
-
 #include "../Result.hpp"
 
 namespace rfl {
diff --git a/include/rfl/internal/all_fields.hpp b/include/rfl/internal/all_fields.hpp
index 169803ba..9d9190b1 100644
--- a/include/rfl/internal/all_fields.hpp
+++ b/include/rfl/internal/all_fields.hpp
@@ -1,10 +1,6 @@
 #ifndef RFL_INTERNAL_ALLFIELDS_HPP_
 #define RFL_INTERNAL_ALLFIELDS_HPP_
 
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
 #include "../Tuple.hpp"
 #include "is_field.hpp"
 
diff --git a/include/rfl/internal/bind_to_tuple.hpp b/include/rfl/internal/bind_to_tuple.hpp
index fb35632f..5ffaada7 100644
--- a/include/rfl/internal/bind_to_tuple.hpp
+++ b/include/rfl/internal/bind_to_tuple.hpp
@@ -3,13 +3,11 @@
 
 #include <cassert>
 #include <cstddef>
-#include <iostream>
-#include <type_traits>
 #include <utility>
 
 #include "../Tuple.hpp"
 #include "../always_false.hpp"
-#include "is_named_tuple.hpp"
+//#include "is_named_tuple.hpp" //Not here
 #include "num_fields.hpp"
 
 namespace rfl::internal {
diff --git a/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp b/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp
index 0edb7825..543f1e18 100644
--- a/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp
+++ b/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_COPY_FLATTENED_TUPLE_TO_NAMED_TUPLE_HPP_
 #define RFL_INTERNAL_COPY_FLATTENED_TUPLE_TO_NAMED_TUPLE_HPP_
 
-#include <functional>
-#include <tuple>
 #include <type_traits>
 #include <utility>
 
diff --git a/include/rfl/internal/enums/Names.hpp b/include/rfl/internal/enums/Names.hpp
index 16a3d18b..a35944ad 100644
--- a/include/rfl/internal/enums/Names.hpp
+++ b/include/rfl/internal/enums/Names.hpp
@@ -1,18 +1,16 @@
 #ifndef RFL_INTERNAL_ENUMS_NAMES_HPP_
 #define RFL_INTERNAL_ENUMS_NAMES_HPP_
 
-#include <algorithm>
 #include <array>
-#include <string>
 #include <string_view>
 #include <type_traits>
 #include <utility>
 
 #include "../../Literal.hpp"
-#include "../../config.hpp"
-#include "../../define_literal.hpp"
+//#include "../../config.hpp"
+//#include "../../define_literal.hpp"
 #include "../../make_named_tuple.hpp"
-#include "../../thirdparty/enchantum/enchantum.hpp"
+//#include "../../thirdparty/enchantum/enchantum.hpp"
 #include "../StringLiteral.hpp"
 
 namespace rfl::internal::enums {
diff --git a/include/rfl/internal/enums/get_enum_names.hpp b/include/rfl/internal/enums/get_enum_names.hpp
index 724837ee..b81a7153 100644
--- a/include/rfl/internal/enums/get_enum_names.hpp
+++ b/include/rfl/internal/enums/get_enum_names.hpp
@@ -28,12 +28,11 @@
 #define ENCHANTUM_MAX_RANGE RFL_ENUM_RANGE_MAX
 
 #include <concepts>
-#include <limits>
-#include <type_traits>
 #include <utility>
 
+#include "../../thirdparty/enchantum/enchantum.hpp"// NOLINT(unused-includes)
+
 #include "../../Literal.hpp"
-#include "../../thirdparty/enchantum/enchantum.hpp"
 #include "Names.hpp"
 #include "range_defined.hpp"
 
diff --git a/include/rfl/internal/enums/range_defined.hpp b/include/rfl/internal/enums/range_defined.hpp
index ec6ba5f3..5f87f50b 100644
--- a/include/rfl/internal/enums/range_defined.hpp
+++ b/include/rfl/internal/enums/range_defined.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_ENUMS_RANGE_DEFINED_HPP_
 #define RFL_INTERNAL_ENUMS_RANGE_DEFINED_HPP_
 
-#include <concepts>
-
 #include "../../config.hpp"
 
 namespace rfl::internal::enums {
diff --git a/include/rfl/internal/field_tuple_t.hpp b/include/rfl/internal/field_tuple_t.hpp
index 4a3f9b30..186b12f0 100644
--- a/include/rfl/internal/field_tuple_t.hpp
+++ b/include/rfl/internal/field_tuple_t.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_FIELD_TUPLE_T_HPP_
 #define RFL_INTERNAL_FIELD_TUPLE_T_HPP_
 
-#include <functional>
-#include <tuple>
 #include <type_traits>
 
 #include "copy_to_field_tuple.hpp"
diff --git a/include/rfl/internal/field_type.hpp b/include/rfl/internal/field_type.hpp
index 228ec06c..6d4f7281 100644
--- a/include/rfl/internal/field_type.hpp
+++ b/include/rfl/internal/field_type.hpp
@@ -1,11 +1,10 @@
 #ifndef RFL_INTERNAL_FIELD_TYPE_HPP_
 #define RFL_INTERNAL_FIELD_TYPE_HPP_
 
-#include <tuple>
 #include <type_traits>
 #include <variant>
 
-#include "../NamedTuple.hpp"
+//#include "../NamedTuple.hpp"
 #include "../TaggedUnion.hpp"
 #include "../Tuple.hpp"
 #include "../named_tuple_t.hpp"
diff --git a/include/rfl/internal/find_index.hpp b/include/rfl/internal/find_index.hpp
index fdc2e8f9..347d27b7 100644
--- a/include/rfl/internal/find_index.hpp
+++ b/include/rfl/internal/find_index.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_FIND_INDEX_HPP_
 #define RFL_FIND_INDEX_HPP_
 
-#include <type_traits>
-
 #include "StringLiteral.hpp"
 
 namespace rfl {
diff --git a/include/rfl/internal/flattened_ptr_tuple_t.hpp b/include/rfl/internal/flattened_ptr_tuple_t.hpp
index 917a4548..9c8a3f3c 100644
--- a/include/rfl/internal/flattened_ptr_tuple_t.hpp
+++ b/include/rfl/internal/flattened_ptr_tuple_t.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_FLATTENED_PTR_TUPLE_T_HPP_
 #define RFL_INTERNAL_FLATTENED_PTR_TUPLE_T_HPP_
 
-#include <functional>
 #include <type_traits>
 
 #include "to_flattened_ptr_tuple.hpp"
diff --git a/include/rfl/internal/flattened_tuple_t.hpp b/include/rfl/internal/flattened_tuple_t.hpp
index 65f755b0..05771023 100644
--- a/include/rfl/internal/flattened_tuple_t.hpp
+++ b/include/rfl/internal/flattened_tuple_t.hpp
@@ -1,13 +1,9 @@
 #ifndef RFL_INTERNAL_FLATTENED_TUPLE_T_HPP_
 #define RFL_INTERNAL_FLATTENED_TUPLE_T_HPP_
 
-#include <functional>
-#include <tuple>
-#include <type_traits>
-
 #include "flattened_ptr_tuple_t.hpp"
 #include "remove_ptrs_tup.hpp"
-#include "../to_named_tuple.hpp"
+//#include "../to_named_tuple.hpp"
 
 namespace rfl {
 namespace internal {
diff --git a/include/rfl/internal/get_ith_field_from_fake_object.hpp b/include/rfl/internal/get_ith_field_from_fake_object.hpp
index 57ad393f..6707ae11 100644
--- a/include/rfl/internal/get_ith_field_from_fake_object.hpp
+++ b/include/rfl/internal/get_ith_field_from_fake_object.hpp
@@ -2,10 +2,7 @@
 #define RFL_INTERNAL_GET_ITH_FIELD_FROM_FAKE_OBJECT_HPP_
 
 #include <cstddef>
-#include <iostream>
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../always_false.hpp"
 #include "get_fake_object.hpp"
diff --git a/include/rfl/internal/get_meta_fields.hpp b/include/rfl/internal/get_meta_fields.hpp
index 30cb0812..6468210f 100644
--- a/include/rfl/internal/get_meta_fields.hpp
+++ b/include/rfl/internal/get_meta_fields.hpp
@@ -2,7 +2,6 @@
 #define RFL_INTERNAL_GETMETAFIELDS_HPP_
 
 #include <array>
-#include <tuple>
 #include <utility>
 
 #include "../MetaField.hpp"
diff --git a/include/rfl/internal/has_custom_parser.hpp b/include/rfl/internal/has_custom_parser.hpp
index 40b5720d..a8743288 100644
--- a/include/rfl/internal/has_custom_parser.hpp
+++ b/include/rfl/internal/has_custom_parser.hpp
@@ -3,7 +3,7 @@
 
 #include <type_traits>
 
-#include "../parsing/Parser.hpp"
+//#include "../parsing/Parser.hpp"
 
 namespace rfl::internal {
 
diff --git a/include/rfl/internal/has_fields.hpp b/include/rfl/internal/has_fields.hpp
index dcfc7ded..412b87b0 100644
--- a/include/rfl/internal/has_fields.hpp
+++ b/include/rfl/internal/has_fields.hpp
@@ -1,15 +1,16 @@
 #ifndef RFL_INTERNAL_HASFIELDS_HPP_
 #define RFL_INTERNAL_HASFIELDS_HPP_
 
-#include <tuple>
 #include <type_traits>
 #include <utility>
 
 #include "../Tuple.hpp"
-#include "all_fields.hpp"
+//#include "all_fields.hpp"
 #include "is_field.hpp"
 #include "is_flatten_field.hpp"
 #include "ptr_tuple_t.hpp"
+#include "is_named_tuple.hpp"
+
 
 namespace rfl {
 namespace internal {
diff --git a/include/rfl/internal/has_flatten_fields.hpp b/include/rfl/internal/has_flatten_fields.hpp
index ed872d31..42209e7a 100644
--- a/include/rfl/internal/has_flatten_fields.hpp
+++ b/include/rfl/internal/has_flatten_fields.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_HASFLATTENFIELDS_HPP_
 #define RFL_INTERNAL_HASFLATTENFIELDS_HPP_
 
-#include <tuple>
 #include <type_traits>
 #include <utility>
 
diff --git a/include/rfl/internal/has_reflector.hpp b/include/rfl/internal/has_reflector.hpp
index 8392bea8..cfc1b80b 100644
--- a/include/rfl/internal/has_reflector.hpp
+++ b/include/rfl/internal/has_reflector.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_HASREFLECTOR_HPP_
 #define RFL_INTERNAL_HASREFLECTOR_HPP_
 
-#include <type_traits>
-
 namespace rfl {
 template <typename T>
 struct Reflector;
diff --git a/include/rfl/internal/has_tag_v.hpp b/include/rfl/internal/has_tag_v.hpp
index 29d20f5d..3affc143 100644
--- a/include/rfl/internal/has_tag_v.hpp
+++ b/include/rfl/internal/has_tag_v.hpp
@@ -2,7 +2,6 @@
 #define RFL_HASTAGV_HPP_
 
 #include <cstdint>
-#include <utility>
 
 namespace rfl {
 namespace internal {
diff --git a/include/rfl/internal/is_add_tags_to_variants_v.hpp b/include/rfl/internal/is_add_tags_to_variants_v.hpp
index 59fac0d5..9086a6f0 100644
--- a/include/rfl/internal/is_add_tags_to_variants_v.hpp
+++ b/include/rfl/internal/is_add_tags_to_variants_v.hpp
@@ -1,11 +1,9 @@
 #ifndef RFL_INTERNAL_ISADDTAGSTOVARIANTS_HPP_
 #define RFL_INTERNAL_ISADDTAGSTOVARIANTS_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
-#include "../AddTagsToVariants.hpp"
+//#include "../AddTagsToVariants.hpp"
 
 namespace rfl ::internal {
 
diff --git a/include/rfl/internal/is_allow_raw_ptrs_v.hpp b/include/rfl/internal/is_allow_raw_ptrs_v.hpp
index d29e1430..3b3e51ae 100644
--- a/include/rfl/internal/is_allow_raw_ptrs_v.hpp
+++ b/include/rfl/internal/is_allow_raw_ptrs_v.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISALLOWRAWPTRS_HPP_
 #define RFL_INTERNAL_ISALLOWRAWPTRS_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../AllowRawPtrs.hpp"
 
diff --git a/include/rfl/internal/is_array.hpp b/include/rfl/internal/is_array.hpp
index 093eed4a..42ff45d9 100644
--- a/include/rfl/internal/is_array.hpp
+++ b/include/rfl/internal/is_array.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISARRAY_HPP_
 #define RFL_INTERNAL_ISARRAY_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "Array.hpp"
 
diff --git a/include/rfl/internal/is_attribute.hpp b/include/rfl/internal/is_attribute.hpp
index bf125c11..b51d4e49 100644
--- a/include/rfl/internal/is_attribute.hpp
+++ b/include/rfl/internal/is_attribute.hpp
@@ -1,12 +1,10 @@
 #ifndef RFL_INTERNAL_ISATTRIBUTE_HPP_
 #define RFL_INTERNAL_ISATTRIBUTE_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../Attribute.hpp"
-#include "../Field.hpp"
+//#include "../Field.hpp"
 #include "remove_rename.hpp"
 
 namespace rfl {
diff --git a/include/rfl/internal/is_default_if_missing_v.hpp b/include/rfl/internal/is_default_if_missing_v.hpp
index 81639183..72e5c208 100644
--- a/include/rfl/internal/is_default_if_missing_v.hpp
+++ b/include/rfl/internal/is_default_if_missing_v.hpp
@@ -1,11 +1,9 @@
 #ifndef RFL_INTERNAL_ISDEFAULTIFMISSING_HPP_
 #define RFL_INTERNAL_ISDEFAULTIFMISSING_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
-#include "../DefaultIfMissing.hpp"
+//#include "../DefaultIfMissing.hpp"
 
 namespace rfl {
 namespace internal {
diff --git a/include/rfl/internal/is_description.hpp b/include/rfl/internal/is_description.hpp
index e7234f6c..6349c43a 100644
--- a/include/rfl/internal/is_description.hpp
+++ b/include/rfl/internal/is_description.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISDESCRIPTION_HPP_
 #define RFL_INTERNAL_ISDESCRIPTION_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../Description.hpp"
 #include "StringLiteral.hpp"
diff --git a/include/rfl/internal/is_empty.hpp b/include/rfl/internal/is_empty.hpp
index 9b1dddf2..49e018b5 100644
--- a/include/rfl/internal/is_empty.hpp
+++ b/include/rfl/internal/is_empty.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_ISEMPTY_HPP_
 #define RFL_INTERNAL_ISEMPTY_HPP_
 
-#include <tuple>
 #include <type_traits>
 
 #include "../Tuple.hpp"
diff --git a/include/rfl/internal/is_field.hpp b/include/rfl/internal/is_field.hpp
index f0a81df4..4a210814 100644
--- a/include/rfl/internal/is_field.hpp
+++ b/include/rfl/internal/is_field.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISFIELD_HPP_
 #define RFL_INTERNAL_ISFIELD_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../Field.hpp"
 #include "StringLiteral.hpp"
diff --git a/include/rfl/internal/is_flatten_field.hpp b/include/rfl/internal/is_flatten_field.hpp
index d247f52b..bc7619a8 100644
--- a/include/rfl/internal/is_flatten_field.hpp
+++ b/include/rfl/internal/is_flatten_field.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISFLATTENFIELD_HPP_
 #define RFL_INTERNAL_ISFLATTENFIELD_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../Flatten.hpp"
 
diff --git a/include/rfl/internal/is_no_extra_fields_v.hpp b/include/rfl/internal/is_no_extra_fields_v.hpp
index 58916ee6..1c624534 100644
--- a/include/rfl/internal/is_no_extra_fields_v.hpp
+++ b/include/rfl/internal/is_no_extra_fields_v.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISNOEXTRAFIELDS_HPP_
 #define RFL_INTERNAL_ISNOEXTRAFIELDS_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../NoExtraFields.hpp"
 
diff --git a/include/rfl/internal/is_no_field_names_v.hpp b/include/rfl/internal/is_no_field_names_v.hpp
index 6fea2bcd..2b00b704 100644
--- a/include/rfl/internal/is_no_field_names_v.hpp
+++ b/include/rfl/internal/is_no_field_names_v.hpp
@@ -1,11 +1,9 @@
 #ifndef RFL_INTERNAL_ISNOFIELDNAMES_HPP_
 #define RFL_INTERNAL_ISNOFIELDNAMES_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
-#include "../NoFieldNames.hpp"
+//#include "../NoFieldNames.hpp"
 
 namespace rfl {
 namespace internal {
diff --git a/include/rfl/internal/is_no_optionals_v.hpp b/include/rfl/internal/is_no_optionals_v.hpp
index 1f5861b1..e2e2bc1f 100644
--- a/include/rfl/internal/is_no_optionals_v.hpp
+++ b/include/rfl/internal/is_no_optionals_v.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISNOOPTIONALS_HPP_
 #define RFL_INTERNAL_ISNOOPTIONALS_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../NoOptionals.hpp"
 
diff --git a/include/rfl/internal/is_rename.hpp b/include/rfl/internal/is_rename.hpp
index c518161b..45642bf2 100644
--- a/include/rfl/internal/is_rename.hpp
+++ b/include/rfl/internal/is_rename.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISRENAME_HPP_
 #define RFL_INTERNAL_ISRENAME_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../Rename.hpp"
 #include "StringLiteral.hpp"
diff --git a/include/rfl/internal/is_underlying_enums_v.hpp b/include/rfl/internal/is_underlying_enums_v.hpp
index 1a9479ca..f0570e9c 100644
--- a/include/rfl/internal/is_underlying_enums_v.hpp
+++ b/include/rfl/internal/is_underlying_enums_v.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_ISUNDERLYINGENUMS_HPP_
 #define RFL_INTERNAL_ISUNDERLYINGENUMS_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../UnderlyingEnums.hpp"
 
diff --git a/include/rfl/internal/move_and_flatten_field_tuple.hpp b/include/rfl/internal/move_and_flatten_field_tuple.hpp
index 75e0e38c..a943ef89 100644
--- a/include/rfl/internal/move_and_flatten_field_tuple.hpp
+++ b/include/rfl/internal/move_and_flatten_field_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_MOVE_AND_FLATTEN_FIELD_TUPLE_HPP_
 #define RFL_INTERNAL_MOVE_AND_FLATTEN_FIELD_TUPLE_HPP_
 
-#include <tuple>
-
 #include "../Tuple.hpp"
 #include "../tuple_cat.hpp"
 #include "is_flatten_field.hpp"
diff --git a/include/rfl/internal/move_field_tuple_to_named_tuple.hpp b/include/rfl/internal/move_field_tuple_to_named_tuple.hpp
index cd4ff666..05c035af 100644
--- a/include/rfl/internal/move_field_tuple_to_named_tuple.hpp
+++ b/include/rfl/internal/move_field_tuple_to_named_tuple.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_MOVE_FIELD_TUPLE_TO_NAMED_TUPLE_HPP_
 #define RFL_INTERNAL_MOVE_FIELD_TUPLE_TO_NAMED_TUPLE_HPP_
 
-#include <tuple>
 #include <type_traits>
 
 #include "../Field.hpp"
diff --git a/include/rfl/internal/move_from_named_tuple.hpp b/include/rfl/internal/move_from_named_tuple.hpp
index eca9d9e9..617bcb16 100644
--- a/include/rfl/internal/move_from_named_tuple.hpp
+++ b/include/rfl/internal/move_from_named_tuple.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_MOVE_FROM_NAMED_TUPLE_HPP_
 #define RFL_MOVE_FROM_NAMED_TUPLE_HPP_
 
-#include <functional>
 #include <type_traits>
 
 #include "../Tuple.hpp"
diff --git a/include/rfl/internal/move_from_tuple.hpp b/include/rfl/internal/move_from_tuple.hpp
index 974d201b..0905a567 100644
--- a/include/rfl/internal/move_from_tuple.hpp
+++ b/include/rfl/internal/move_from_tuple.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_MOVE_FROM_TUPLE_HPP_
 #define RFL_MOVE_FROM_TUPLE_HPP_
 
-#include <functional>
 #include <type_traits>
 
 #include "../Tuple.hpp"
diff --git a/include/rfl/internal/move_to_field_tuple.hpp b/include/rfl/internal/move_to_field_tuple.hpp
index 187436b7..be647e6b 100644
--- a/include/rfl/internal/move_to_field_tuple.hpp
+++ b/include/rfl/internal/move_to_field_tuple.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_MOVE_TO_FIELD_TUPLE_HPP_
 #define RFL_INTERNAL_MOVE_TO_FIELD_TUPLE_HPP_
 
-#include <tuple>
 #include <type_traits>
 
 #include "../Tuple.hpp"
diff --git a/include/rfl/internal/nt_to_ptr_named_tuple.hpp b/include/rfl/internal/nt_to_ptr_named_tuple.hpp
index bb9f7f1e..641cbd0a 100644
--- a/include/rfl/internal/nt_to_ptr_named_tuple.hpp
+++ b/include/rfl/internal/nt_to_ptr_named_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_NT_TO_PTR_NAMED_TUPLE_HPP_
 #define RFL_INTERNAL_NT_TO_PTR_NAMED_TUPLE_HPP_
 
-#include <tuple>
-
 #include "../Field.hpp"
 #include "../Tuple.hpp"
 #include "../make_named_tuple.hpp"
diff --git a/include/rfl/internal/nth_element.hpp b/include/rfl/internal/nth_element.hpp
index ff32a6c5..281e5968 100644
--- a/include/rfl/internal/nth_element.hpp
+++ b/include/rfl/internal/nth_element.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_NTH_ELEMENT_HPP_
 #define RFL_INTERNAL_NTH_ELEMENT_HPP_
 
-#include <tuple>
 #include <utility>
 
 namespace rfl::internal {
diff --git a/include/rfl/internal/nth_element_t.hpp b/include/rfl/internal/nth_element_t.hpp
index 793657b1..016a121f 100644
--- a/include/rfl/internal/nth_element_t.hpp
+++ b/include/rfl/internal/nth_element_t.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_NTH_ELEMENT_T_HPP_
 #define RFL_INTERNAL_NTH_ELEMENT_T_HPP_
 
-#include <type_traits>
-
 #include "nth_element.hpp"
 
 namespace rfl::internal {
diff --git a/include/rfl/internal/num_fields.hpp b/include/rfl/internal/num_fields.hpp
index fdff100e..39de8b4a 100644
--- a/include/rfl/internal/num_fields.hpp
+++ b/include/rfl/internal/num_fields.hpp
@@ -29,7 +29,6 @@ the potential array as we can without missing variables in subsequent fields.
 This is the purpose of get_nested_array_size().
 */
 
-#include <algorithm>
 #include <cstddef>
 #include <type_traits>
 #include <utility>
diff --git a/include/rfl/internal/ptr_cast.hpp b/include/rfl/internal/ptr_cast.hpp
index 0ca80450..9efba7aa 100644
--- a/include/rfl/internal/ptr_cast.hpp
+++ b/include/rfl/internal/ptr_cast.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_PTRCAST_HPP_
 #define RFL_INTERNAL_PTRCAST_HPP_
 
-#include <bit>
-
 namespace rfl::internal {
 
 /// Normally, we would use std::launder(reinterpret_cast<...>(...)),
diff --git a/include/rfl/internal/ptr_field_tuple_t.hpp b/include/rfl/internal/ptr_field_tuple_t.hpp
index 969220d4..9b20a9b9 100644
--- a/include/rfl/internal/ptr_field_tuple_t.hpp
+++ b/include/rfl/internal/ptr_field_tuple_t.hpp
@@ -1,10 +1,6 @@
 #ifndef RFL_INTERNAL_PTR_NAMED_TUPLE_T_HPP_
 #define RFL_INTERNAL_PTR_NAMED_TUPLE_T_HPP_
 
-#include <functional>
-#include <tuple>
-#include <type_traits>
-
 #include "to_ptr_field_tuple.hpp"
 
 namespace rfl {
diff --git a/include/rfl/internal/ptr_named_tuple_t.hpp b/include/rfl/internal/ptr_named_tuple_t.hpp
index 7b7544b5..f8c88ef0 100644
--- a/include/rfl/internal/ptr_named_tuple_t.hpp
+++ b/include/rfl/internal/ptr_named_tuple_t.hpp
@@ -1,11 +1,9 @@
 #ifndef RFL_INTERNAL_PTR_FIELD_TUPLE_T_HPP_
 #define RFL_INTERNAL_PTR_FIELD_TUPLE_T_HPP_
 
-#include <functional>
-#include <tuple>
 #include <type_traits>
 
-#include "is_named_tuple.hpp"
+//#include "is_named_tuple.hpp"//Not here
 #include "to_ptr_named_tuple.hpp"
 
 namespace rfl {
diff --git a/include/rfl/internal/ptr_tuple_t.hpp b/include/rfl/internal/ptr_tuple_t.hpp
index f015bad9..1a11965e 100644
--- a/include/rfl/internal/ptr_tuple_t.hpp
+++ b/include/rfl/internal/ptr_tuple_t.hpp
@@ -1,9 +1,6 @@
 #ifndef RFL_INTERNAL_PTR_TUPLE_T_HPP_
 #define RFL_INTERNAL_PTR_TUPLE_T_HPP_
 
-#include <functional>
-#include <type_traits>
-
 #include "to_ptr_tuple.hpp"
 
 namespace rfl {
diff --git a/include/rfl/internal/remove_fields.hpp b/include/rfl/internal/remove_fields.hpp
index c411507b..c0ec676e 100644
--- a/include/rfl/internal/remove_fields.hpp
+++ b/include/rfl/internal/remove_fields.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_REMOVEFIELDS_HPP_
 #define RFL_INTERNAL_REMOVEFIELDS_HPP_
 
-#include <algorithm>
-#include <tuple>
 #include <type_traits>
 
 #include "../NamedTuple.hpp"
diff --git a/include/rfl/internal/remove_ptrs_nt.hpp b/include/rfl/internal/remove_ptrs_nt.hpp
index dbd3eff8..97a3d16a 100644
--- a/include/rfl/internal/remove_ptrs_nt.hpp
+++ b/include/rfl/internal/remove_ptrs_nt.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_REMOVE_PTRS_NT_HPP_
 #define RFL_INTERNAL_REMOVE_PTRS_NT_HPP_
 
-#include <functional>
 #include <type_traits>
 
 #include "../Field.hpp"
diff --git a/include/rfl/internal/remove_ptrs_tup.hpp b/include/rfl/internal/remove_ptrs_tup.hpp
index d81f14d6..94257650 100644
--- a/include/rfl/internal/remove_ptrs_tup.hpp
+++ b/include/rfl/internal/remove_ptrs_tup.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_REMOVE_PTRS_TUP_HPP_
 #define RFL_INTERNAL_REMOVE_PTRS_TUP_HPP_
 
-#include <functional>
 #include <type_traits>
 
 #include "../Tuple.hpp"
diff --git a/include/rfl/internal/remove_rename.hpp b/include/rfl/internal/remove_rename.hpp
index d371dffb..09321e36 100644
--- a/include/rfl/internal/remove_rename.hpp
+++ b/include/rfl/internal/remove_rename.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_INTERNAL_REMOVERENAME_HPP_
 #define RFL_INTERNAL_REMOVERENAME_HPP_
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include "../Rename.hpp"
 #include "StringLiteral.hpp"
diff --git a/include/rfl/internal/to_flattened_ptr_tuple.hpp b/include/rfl/internal/to_flattened_ptr_tuple.hpp
index 81a1bff0..2287d94a 100644
--- a/include/rfl/internal/to_flattened_ptr_tuple.hpp
+++ b/include/rfl/internal/to_flattened_ptr_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_TO_FLATTENED_PTR_TUPLE_HPP_
 #define RFL_INTERNAL_TO_FLATTENED_PTR_TUPLE_HPP_
 
-#include <tuple>
-
 #include "../Tuple.hpp"
 #include "../tuple_cat.hpp"
 #include "has_flatten_fields.hpp"
diff --git a/include/rfl/internal/to_ptr_field_tuple.hpp b/include/rfl/internal/to_ptr_field_tuple.hpp
index e7877130..e8bd354e 100644
--- a/include/rfl/internal/to_ptr_field_tuple.hpp
+++ b/include/rfl/internal/to_ptr_field_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_TO_PTR_FIELD_TUPLE_HPP_
 #define RFL_INTERNAL_TO_PTR_FIELD_TUPLE_HPP_
 
-#include <iostream>
-#include <tuple>
 #include <type_traits>
 
 #include "../field_names_t.hpp"
diff --git a/include/rfl/internal/to_ptr_named_tuple.hpp b/include/rfl/internal/to_ptr_named_tuple.hpp
index 87a35bb2..eeb25fdb 100644
--- a/include/rfl/internal/to_ptr_named_tuple.hpp
+++ b/include/rfl/internal/to_ptr_named_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_TO_PTR_NAMED_TUPLE_HPP_
 #define RFL_INTERNAL_TO_PTR_NAMED_TUPLE_HPP_
 
-#include <iostream>
-#include <tuple>
 
 #include "../Tuple.hpp"
 #include "../always_false.hpp"
diff --git a/include/rfl/internal/to_ptr_tuple.hpp b/include/rfl/internal/to_ptr_tuple.hpp
index 3eefebe5..076a5e53 100644
--- a/include/rfl/internal/to_ptr_tuple.hpp
+++ b/include/rfl/internal/to_ptr_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_TO_PTR_TUPLE_HPP_
 #define RFL_INTERNAL_TO_PTR_TUPLE_HPP_
 
-#include <iostream>
-#include <tuple>
 #include <type_traits>
 
 #include "bind_to_tuple.hpp"
diff --git a/include/rfl/internal/to_std_array.hpp b/include/rfl/internal/to_std_array.hpp
index bb93f255..4d9a936e 100644
--- a/include/rfl/internal/to_std_array.hpp
+++ b/include/rfl/internal/to_std_array.hpp
@@ -2,7 +2,6 @@
 #define RFL_INTERNAL_TO_STD_ARRAY_HPP_
 
 #include <array>
-#include <cstdint>
 #include <type_traits>
 
 namespace rfl::internal {
diff --git a/include/rfl/internal/tup_to_ptr_tuple.hpp b/include/rfl/internal/tup_to_ptr_tuple.hpp
index 063e3d93..3e8bfdb1 100644
--- a/include/rfl/internal/tup_to_ptr_tuple.hpp
+++ b/include/rfl/internal/tup_to_ptr_tuple.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_INTERNAL_TUP_TO_PTR_TUPLE_HPP_
 #define RFL_INTERNAL_TUP_TO_PTR_TUPLE_HPP_
 
-#include <tuple>
-
 #include "../Field.hpp"
 #include "../Tuple.hpp"
 #include "../apply.hpp"
diff --git a/include/rfl/internal/tuple/accumulate_sizes.hpp b/include/rfl/internal/tuple/accumulate_sizes.hpp
index defb5a83..b33347c9 100644
--- a/include/rfl/internal/tuple/accumulate_sizes.hpp
+++ b/include/rfl/internal/tuple/accumulate_sizes.hpp
@@ -2,7 +2,6 @@
 #define RFL_INTERNAL_TUPLE_ACCUMULATE_SIZES_HPP_
 
 #include <array>
-#include <utility>
 
 namespace rfl::internal::tuple {
 
@@ -17,8 +16,8 @@ struct Sizes {
 };
 
 template <class T, unsigned long _last, unsigned long... _is>
-consteval auto operator+(const Sizes<_last, _is...>& _sizes,
-                         const SizeWrapper<T>& _w) {
+consteval auto operator+(const Sizes<_last, _is...>& /*_sizes*/,
+                         const SizeWrapper<T>& /*_w*/) {
   if constexpr (_last % alignof(T) == 0) {
     constexpr auto last_new = _last + sizeof(T);
     return Sizes<last_new, _is..., _last>{};
diff --git a/include/rfl/internal/tuple/calculate_positions.hpp b/include/rfl/internal/tuple/calculate_positions.hpp
index 20e375b9..416d3451 100644
--- a/include/rfl/internal/tuple/calculate_positions.hpp
+++ b/include/rfl/internal/tuple/calculate_positions.hpp
@@ -2,7 +2,6 @@
 #define RFL_INTERNAL_TUPLE_CALCULATE_POSITIONS_HPP_
 
 #include <array>
-#include <utility>
 
 namespace rfl::internal::tuple {
 
diff --git a/include/rfl/internal/tuple_t.hpp b/include/rfl/internal/tuple_t.hpp
index 71b0086d..2d09c07a 100644
--- a/include/rfl/internal/tuple_t.hpp
+++ b/include/rfl/internal/tuple_t.hpp
@@ -1,10 +1,6 @@
 #ifndef RFL_INTERNAL_TUPLE_T_HPP_
 #define RFL_INTERNAL_TUPLE_T_HPP_
 
-#include <functional>
-#include <tuple>
-#include <type_traits>
-
 #include "ptr_tuple_t.hpp"
 #include "remove_ptrs_tup.hpp"
 #include "../to_named_tuple.hpp"
diff --git a/include/rfl/internal/wrap_in_fields.hpp b/include/rfl/internal/wrap_in_fields.hpp
index ed9ae3ad..93838f2c 100644
--- a/include/rfl/internal/wrap_in_fields.hpp
+++ b/include/rfl/internal/wrap_in_fields.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_INTERNAL_WRAP_IN_FIELDS_HPP_
 #define RFL_INTERNAL_WRAP_IN_FIELDS_HPP_
 
-#include <tuple>
 #include <type_traits>
 
 #include "../Tuple.hpp"
diff --git a/include/rfl/io/load_string.hpp b/include/rfl/io/load_string.hpp
index a279aab5..8718632b 100644
--- a/include/rfl/io/load_string.hpp
+++ b/include/rfl/io/load_string.hpp
@@ -2,7 +2,6 @@
 #define RFL_IO_LOAD_STRING_HPP_
 
 #include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/io/save_bytes.hpp b/include/rfl/io/save_bytes.hpp
index d0eb1176..0c5fc208 100644
--- a/include/rfl/io/save_bytes.hpp
+++ b/include/rfl/io/save_bytes.hpp
@@ -4,7 +4,6 @@
 #include <fstream>
 #include <iostream>
 #include <string>
-#include <vector>
 
 #include "../Result.hpp"
 
diff --git a/include/rfl/io/save_string.hpp b/include/rfl/io/save_string.hpp
index 8f02336a..f7c7e6e3 100644
--- a/include/rfl/io/save_string.hpp
+++ b/include/rfl/io/save_string.hpp
@@ -2,7 +2,6 @@
 #define RFL_IO_SAVE_STRING_HPP_
 
 #include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/json/Reader.hpp b/include/rfl/json/Reader.hpp
index 4bcfbf45..ac75f738 100644
--- a/include/rfl/json/Reader.hpp
+++ b/include/rfl/json/Reader.hpp
@@ -7,18 +7,10 @@
 #include "../thirdparty/yyjson.h"
 #endif
 
-#include <array>
-#include <concepts>
 #include <exception>
-#include <map>
-#include <memory>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <unordered_map>
-#include <vector>
 
 #include "../Result.hpp"
 #include "../always_false.hpp"
diff --git a/include/rfl/json/Writer.hpp b/include/rfl/json/Writer.hpp
index 6b02c83e..c1521f87 100644
--- a/include/rfl/json/Writer.hpp
+++ b/include/rfl/json/Writer.hpp
@@ -7,16 +7,11 @@
 #include "../thirdparty/yyjson.h"
 #endif
 
-#include <exception>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <vector>
 
-#include "../Result.hpp"
+//#include "../Result.hpp"
 #include "../always_false.hpp"
 
 namespace rfl {
diff --git a/include/rfl/json/save.hpp b/include/rfl/json/save.hpp
index c2010f55..925df88e 100644
--- a/include/rfl/json/save.hpp
+++ b/include/rfl/json/save.hpp
@@ -7,8 +7,6 @@
 #include "../thirdparty/yyjson.h"
 #endif
 
-#include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
@@ -21,8 +19,8 @@ namespace json {
 template <class... Ps>
 Result<Nothing> save(const std::string& _fname, const auto& _obj,
                      const yyjson_write_flag _flag = 0) {
-  const auto write_func = [_flag](const auto& _obj, auto& _stream) -> auto& {
-    return write<Ps...>(_obj, _stream, _flag);
+  const auto write_func = [_flag](const auto& _obj_ref, auto& _stream) -> auto& {
+    return write<Ps...>(_obj_ref, _stream, _flag);
   };
   return rfl::io::save_string(_fname, _obj, write_func);
 }
diff --git a/include/rfl/json/schema/JSONSchema.hpp b/include/rfl/json/schema/JSONSchema.hpp
index 7aedfb7b..80e134ae 100644
--- a/include/rfl/json/schema/JSONSchema.hpp
+++ b/include/rfl/json/schema/JSONSchema.hpp
@@ -3,7 +3,6 @@
 
 #include <map>
 #include <string>
-#include <variant>
 
 #include "../../Flatten.hpp"
 #include "../../Literal.hpp"
@@ -15,9 +14,9 @@ namespace rfl::json::schema {
 template <class T>
 struct JSONSchema {
   Rename<"$schema", Literal<"https://json-schema.org/draft/2020-12/schema">>
-      schema;
-  Flatten<T> root;
-  std::map<std::string, Type> definitions;
+      schema{};
+  Flatten<T> root{};
+  std::map<std::string, Type> definitions{};
 };
 
 }  // namespace rfl::json::schema
diff --git a/include/rfl/json/schema/Type.hpp b/include/rfl/json/schema/Type.hpp
index 964354d8..4630a296 100644
--- a/include/rfl/json/schema/Type.hpp
+++ b/include/rfl/json/schema/Type.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_JSON_SCHEMA_TYPE_HPP_
 #define RFL_JSON_SCHEMA_TYPE_HPP_
 
-#include <map>
 #include <memory>
 #include <optional>
 #include <string>
@@ -16,125 +15,125 @@ namespace rfl::json::schema {
 /// The JSON representation of internal::schema::Type.
 struct Type {
   struct Boolean {
-    std::optional<std::string> description;
-    Literal<"boolean"> type;
+    std::optional<std::string> description{};
+    Literal<"boolean"> type{};
   };
 
   struct Integer {
-    Literal<"integer"> type;
-    std::optional<std::string> description;
+    Literal<"integer"> type{};
+    std::optional<std::string> description{};
   };
 
   struct Number {
-    Literal<"number"> type;
-    std::optional<std::string> description;
+    Literal<"number"> type{};
+    std::optional<std::string> description{};
   };
 
   struct String {
-    Literal<"string"> type;
-    std::optional<std::string> description;
-    rfl::Rename<"minLength", std::optional<size_t>> minSize;
-    rfl::Rename<"maxLength", std::optional<size_t>> maxSize;
+    Literal<"string"> type{};
+    std::optional<std::string> description{};
+    rfl::Rename<"minLength", std::optional<size_t>> minSize{};
+    rfl::Rename<"maxLength", std::optional<size_t>> maxSize{};
   };
 
   using NumericType = rfl::Variant<Integer, Number>;
 
   struct AllOf {
-    std::optional<std::string> description;
-    std::vector<Type> allOf;
+    std::optional<std::string> description{};
+    std::vector<Type> allOf{};
   };
 
   struct AnyOf {
-    std::optional<std::string> description;
-    std::vector<Type> anyOf;
+    std::optional<std::string> description{};
+    std::vector<Type> anyOf{};
   };
 
   struct ExclusiveMaximum {
-    std::optional<std::string> description;
-    rfl::Variant<double, int> exclusiveMaximum;
-    std::string type;
+    std::optional<std::string> description{};
+    rfl::Variant<double, int> exclusiveMaximum{};
+    std::string type{};
   };
 
   struct ExclusiveMinimum {
-    std::optional<std::string> description;
-    rfl::Variant<double, int> exclusiveMinimum;
-    std::string type;
+    std::optional<std::string> description{};
+    rfl::Variant<double, int> exclusiveMinimum{};
+    std::string type{};
   };
 
   struct FixedSizeTypedArray {
-    Literal<"array"> type;
-    std::optional<std::string> description;
-    rfl::Ref<Type> items;
-    size_t minItems;
-    size_t maxItems;
+    Literal<"array"> type{};
+    std::optional<std::string> description{};
+    rfl::Ref<Type> items{};
+    size_t minItems{};
+    size_t maxItems{};
   };
 
   struct Maximum {
-    std::optional<std::string> description;
-    rfl::Variant<double, int> maximum;
-    std::string type;
+    std::optional<std::string> description{};
+    rfl::Variant<double, int> maximum{};
+    std::string type{};
   };
 
   struct Minimum {
-    std::optional<std::string> description;
-    rfl::Variant<double, int> minimum;
-    std::string type;
+    std::optional<std::string> description{};
+    rfl::Variant<double, int> minimum{};
+    std::string type{};
   };
 
   struct Null {
-    Literal<"null"> type;
-    std::optional<std::string> description;
+    Literal<"null"> type{};
+    std::optional<std::string> description{};
   };
 
   struct Object {
-    Literal<"object"> type;
-    std::optional<std::string> description;
-    rfl::Object<Type> properties;
-    std::vector<std::string> required;
-    std::shared_ptr<Type> additionalProperties;
+    Literal<"object"> type{};
+    std::optional<std::string> description{};
+    rfl::Object<Type> properties{};
+    std::vector<std::string> required{};
+    std::shared_ptr<Type> additionalProperties{};
   };
 
   struct OneOf {
-    std::optional<std::string> description;
-    std::vector<Type> oneOf;
+    std::optional<std::string> description{};
+    std::vector<Type> oneOf{};
   };
 
   struct Reference {
-    Rename<"$ref", std::optional<std::string>> ref;
-    std::optional<std::string> description;
+    Rename<"$ref", std::optional<std::string>> ref{};
+    std::optional<std::string> description{};
   };
 
   struct Regex {
-    Literal<"string"> type;
-    std::optional<std::string> description;
-    std::string pattern;
+    Literal<"string"> type{};
+    std::optional<std::string> description{};
+    std::string pattern{};
   };
 
   struct StringEnum {
-    Literal<"string"> type;
-    std::optional<std::string> description;
-    rfl::Rename<"enum", std::vector<std::string>> values;
+    Literal<"string"> type{};
+    std::optional<std::string> description{};
+    rfl::Rename<"enum", std::vector<std::string>> values{};
   };
 
   struct StringMap {
-    Literal<"object"> type;
-    std::optional<std::string> description;
-    rfl::Ref<Type> additionalProperties;
+    Literal<"object"> type{};
+    std::optional<std::string> description{};
+    rfl::Ref<Type> additionalProperties{};
   };
 
   struct Tuple {
-    Literal<"array"> type;
-    std::optional<std::string> description;
-    std::vector<Type> prefixItems;
+    Literal<"array"> type{};
+    std::optional<std::string> description{};
+    std::vector<Type> prefixItems{};
     bool items = false;
   };
 
   struct TypedArray {
-    Literal<"array"> type;
-    std::optional<std::string> description;
-    rfl::Ref<Type> items;
-    rfl::Rename<"minItems", std::optional<size_t>> minSize;
-    rfl::Rename<"maxItems", std::optional<size_t>> maxSize;
+    Literal<"array"> type{};
+    std::optional<std::string> description{};
+    rfl::Ref<Type> items{};
+    rfl::Rename<"minItems", std::optional<size_t>> minSize{};
+    rfl::Rename<"maxItems", std::optional<size_t>> maxSize{};
   };
 
   using ReflectionType =
diff --git a/include/rfl/json/to_schema.hpp b/include/rfl/json/to_schema.hpp
index 42a70d2d..a3f71404 100644
--- a/include/rfl/json/to_schema.hpp
+++ b/include/rfl/json/to_schema.hpp
@@ -7,21 +7,19 @@
 #include "../thirdparty/yyjson.h"
 #endif
 
-#include <map>
 #include <string>
-#include <type_traits>
 
-#include "../Literal.hpp"
+//#include "../Literal.hpp"
 #include "../Processors.hpp"
 #include "../Variant.hpp"
-#include "../parsing/schema/Type.hpp"
-#include "../parsing/schema/ValidationType.hpp"
+//#include "../parsing/schema/Type.hpp"
+//#include "../parsing/schema/ValidationType.hpp"
 #include "../parsing/schema/make.hpp"
 #include "Reader.hpp"
 #include "Writer.hpp"
 #include "schema/JSONSchema.hpp"
-#include "schema/Type.hpp"
-#include "write.hpp"
+//#include "schema/Type.hpp"
+//#include "write.hpp"
 
 namespace rfl::json {
 
diff --git a/include/rfl/json/write.hpp b/include/rfl/json/write.hpp
index 7457714d..2f08d6db 100644
--- a/include/rfl/json/write.hpp
+++ b/include/rfl/json/write.hpp
@@ -9,7 +9,6 @@
 #endif
 
 #include <ostream>
-#include <sstream>
 #include <string>
 
 #include "../Processors.hpp"
diff --git a/include/rfl/msgpack/Reader.hpp b/include/rfl/msgpack/Reader.hpp
index 71bbc946..2a0bd625 100644
--- a/include/rfl/msgpack/Reader.hpp
+++ b/include/rfl/msgpack/Reader.hpp
@@ -7,13 +7,12 @@
 #include <exception>
 #include <string>
 #include <string_view>
-#include <type_traits>
 
-#include "../Bytestring.hpp"
+//#include "../Bytestring.hpp"
 #include "../Result.hpp"
-#include "../Vectorstring.hpp"
+//#include "../Vectorstring.hpp"
 #include "../always_false.hpp"
-#include "../internal/ptr_cast.hpp"
+//#include "../internal/ptr_cast.hpp"
 
 namespace rfl {
 namespace msgpack {
diff --git a/include/rfl/msgpack/Writer.hpp b/include/rfl/msgpack/Writer.hpp
index 4f1e6767..50844b74 100644
--- a/include/rfl/msgpack/Writer.hpp
+++ b/include/rfl/msgpack/Writer.hpp
@@ -3,20 +3,14 @@
 
 #include <msgpack.h>
 
-#include <exception>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <variant>
-#include <vector>
 
-#include "../Box.hpp"
+//#include "../Box.hpp"
 #include "../Bytestring.hpp"
-#include "../Ref.hpp"
-#include "../Result.hpp"
+//#include "../Ref.hpp"
+//#include "../Result.hpp"
 #include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 
@@ -65,14 +59,14 @@ class Writer {
 
   template <class T>
   OutputVarType add_value_to_array(const T& _var,
-                                   OutputArrayType* _parent) const noexcept {
+                                   OutputArrayType* /*_parent*/) const noexcept {
     return new_value(_var);
   }
 
   template <class T>
   OutputVarType add_value_to_object(const std::string_view& _name,
                                     const T& _var,
-                                    OutputObjectType* _parent) const noexcept {
+                                    OutputObjectType* /*_parent*/) const noexcept {
     msgpack_pack_str(pk_, _name.size());
     msgpack_pack_str_body(pk_, _name.data(), _name.size());
     return new_value(_var);
diff --git a/include/rfl/msgpack/read.hpp b/include/rfl/msgpack/read.hpp
index b3597264..e5d242de 100644
--- a/include/rfl/msgpack/read.hpp
+++ b/include/rfl/msgpack/read.hpp
@@ -4,7 +4,6 @@
 #include <msgpack.h>
 
 #include <istream>
-#include <string>
 
 #include "../Processors.hpp"
 #include "../concepts.hpp"
diff --git a/include/rfl/msgpack/save.hpp b/include/rfl/msgpack/save.hpp
index 1d2cfe55..3ceaa718 100644
--- a/include/rfl/msgpack/save.hpp
+++ b/include/rfl/msgpack/save.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_MSGPACK_SAVE_HPP_
 #define RFL_MSGPACK_SAVE_HPP_
 
-#include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/msgpack/write.hpp b/include/rfl/msgpack/write.hpp
index 620ebb94..5a9df5f6 100644
--- a/include/rfl/msgpack/write.hpp
+++ b/include/rfl/msgpack/write.hpp
@@ -3,11 +3,7 @@
 
 #include <msgpack.h>
 
-#include <cstdint>
 #include <ostream>
-#include <sstream>
-#include <string>
-#include <utility>
 
 #include "../Processors.hpp"
 #include "../parsing/Parent.hpp"
diff --git a/include/rfl/parquet/read.hpp b/include/rfl/parquet/read.hpp
index 4da4d9f1..2e48ec66 100644
--- a/include/rfl/parquet/read.hpp
+++ b/include/rfl/parquet/read.hpp
@@ -5,10 +5,9 @@
 #include <parquet/arrow/reader.h>
 
 #include <istream>
-#include <memory>
 #include <string>
 
-#include "../Processors.hpp"
+//#include "../Processors.hpp"
 #include "../Result.hpp"
 #include "../concepts.hpp"
 #include "../internal/wrap_in_rfl_array_t.hpp"
diff --git a/include/rfl/parquet/save.hpp b/include/rfl/parquet/save.hpp
index 93929f6e..8a18c08c 100644
--- a/include/rfl/parquet/save.hpp
+++ b/include/rfl/parquet/save.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_PARQUET_SAVE_HPP_
 #define RFL_PARQUET_SAVE_HPP_
 
-#include <fstream>
-#include <iostream>
 #include <string>
 
 #include "../Result.hpp"
diff --git a/include/rfl/parquet/write.hpp b/include/rfl/parquet/write.hpp
index d39147e3..f5087762 100644
--- a/include/rfl/parquet/write.hpp
+++ b/include/rfl/parquet/write.hpp
@@ -4,16 +4,12 @@
 #include <arrow/io/api.h>
 #include <parquet/arrow/writer.h>
 
-#include <cstdint>
 #include <ostream>
-#include <sstream>
 #include <stdexcept>
-#include <string>
 #include <string_view>
-#include <utility>
 
-#include "../Processors.hpp"
-#include "../Ref.hpp"
+//#include "../Processors.hpp"
+//#include "../Ref.hpp"
 #include "../parsing/tabular/ArrowWriter.hpp"
 #include "Settings.hpp"
 
diff --git a/include/rfl/parsing/ArrayReader.hpp b/include/rfl/parsing/ArrayReader.hpp
index ef56e6f4..d3b67b29 100644
--- a/include/rfl/parsing/ArrayReader.hpp
+++ b/include/rfl/parsing/ArrayReader.hpp
@@ -3,9 +3,7 @@
 
 #include <array>
 #include <optional>
-#include <string_view>
 #include <type_traits>
-#include <vector>
 
 #include "../Result.hpp"
 #include "../internal/is_array.hpp"
diff --git a/include/rfl/parsing/CustomParser.hpp b/include/rfl/parsing/CustomParser.hpp
index 7bd7ecb8..dc436031 100644
--- a/include/rfl/parsing/CustomParser.hpp
+++ b/include/rfl/parsing/CustomParser.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_PARSING_CUSTOMPARSER_HPP_
 #define RFL_PARSING_CUSTOMPARSER_HPP_
 
-#include <concepts>
 #include <exception>
-#include <tuple>
 
 #include "../Tuple.hpp"
 #include "../internal/has_to_class_method_v.hpp"
diff --git a/include/rfl/parsing/FieldVariantParser.hpp b/include/rfl/parsing/FieldVariantParser.hpp
index 9374f6ee..cb0db047 100644
--- a/include/rfl/parsing/FieldVariantParser.hpp
+++ b/include/rfl/parsing/FieldVariantParser.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_FIELD_VARIANT_PARSER_HPP_
 
 #include <map>
-#include <stdexcept>
 #include <string>
 #include <type_traits>
 
diff --git a/include/rfl/parsing/FieldVariantReader.hpp b/include/rfl/parsing/FieldVariantReader.hpp
index 06ed2b41..e16ea35f 100644
--- a/include/rfl/parsing/FieldVariantReader.hpp
+++ b/include/rfl/parsing/FieldVariantReader.hpp
@@ -1,13 +1,11 @@
 #ifndef RFL_PARSING_FIELDVARIANTREADER_HPP_
 #define RFL_PARSING_FIELDVARIANTREADER_HPP_
 
-#include <array>
 #include <optional>
 #include <sstream>
 #include <string_view>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "../Result.hpp"
 #include "../Variant.hpp"
diff --git a/include/rfl/parsing/IsReader.hpp b/include/rfl/parsing/IsReader.hpp
index 11b78a03..b80416f0 100644
--- a/include/rfl/parsing/IsReader.hpp
+++ b/include/rfl/parsing/IsReader.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_PARSING_ISREADER_HPP_
 #define RFL_PARSING_ISREADER_HPP_
 
-#include <array>
 #include <concepts>
 #include <cstdint>
 #include <functional>
diff --git a/include/rfl/parsing/MapParser.hpp b/include/rfl/parsing/MapParser.hpp
index e53239e0..25cf69bb 100644
--- a/include/rfl/parsing/MapParser.hpp
+++ b/include/rfl/parsing/MapParser.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_MAPPARSER_HPP_
 
 #include <map>
-#include <stdexcept>
 #include <string>
 #include <type_traits>
 
diff --git a/include/rfl/parsing/NamedTupleParser.hpp b/include/rfl/parsing/NamedTupleParser.hpp
index b1cdfafd..34ac15a4 100644
--- a/include/rfl/parsing/NamedTupleParser.hpp
+++ b/include/rfl/parsing/NamedTupleParser.hpp
@@ -4,9 +4,7 @@
 #include <array>
 #include <map>
 #include <sstream>
-#include <tuple>
 #include <type_traits>
-#include <unordered_map>
 #include <utility>
 
 #include "../NamedTuple.hpp"
diff --git a/include/rfl/parsing/Parent.hpp b/include/rfl/parsing/Parent.hpp
index eb12698d..c8d73be7 100644
--- a/include/rfl/parsing/Parent.hpp
+++ b/include/rfl/parsing/Parent.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_PARSING_PARENT_HPP_
 #define RFL_PARSING_PARENT_HPP_
 
-#include <string>
 #include <string_view>
 #include <type_traits>
 
diff --git a/include/rfl/parsing/Parser_array.hpp b/include/rfl/parsing/Parser_array.hpp
index 3646f363..f907440a 100644
--- a/include/rfl/parsing/Parser_array.hpp
+++ b/include/rfl/parsing/Parser_array.hpp
@@ -2,10 +2,8 @@
 #define RFL_PARSING_PARSER_ARRAY_HPP_
 
 #include <array>
-#include <bit>
 #include <map>
 #include <type_traits>
-#include <vector>
 
 #include "../Ref.hpp"
 #include "../Result.hpp"
diff --git a/include/rfl/parsing/Parser_default.hpp b/include/rfl/parsing/Parser_default.hpp
index 06eaedbd..adc7708b 100644
--- a/include/rfl/parsing/Parser_default.hpp
+++ b/include/rfl/parsing/Parser_default.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_PARSER_DEFAULT_HPP_
 
 #include <map>
-#include <stdexcept>
 #include <type_traits>
 
 #include "../Result.hpp"
diff --git a/include/rfl/parsing/Parser_duration.hpp b/include/rfl/parsing/Parser_duration.hpp
index bf06036c..8f6e995f 100644
--- a/include/rfl/parsing/Parser_duration.hpp
+++ b/include/rfl/parsing/Parser_duration.hpp
@@ -3,7 +3,6 @@
 
 #include <chrono>
 #include <map>
-#include <optional>
 #include <type_traits>
 
 #include "../Literal.hpp"
diff --git a/include/rfl/parsing/Parser_filepath.hpp b/include/rfl/parsing/Parser_filepath.hpp
index b5c93ca3..eecf5763 100644
--- a/include/rfl/parsing/Parser_filepath.hpp
+++ b/include/rfl/parsing/Parser_filepath.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_PARSER_FILEPATH_HPP_
 
 #include <filesystem>
-#include <utility>
 
 #include "../Result.hpp"
 #include "Parser_base.hpp"
diff --git a/include/rfl/parsing/Parser_map_like.hpp b/include/rfl/parsing/Parser_map_like.hpp
index cff1c773..29c3ddcc 100644
--- a/include/rfl/parsing/Parser_map_like.hpp
+++ b/include/rfl/parsing/Parser_map_like.hpp
@@ -2,9 +2,7 @@
 #define RFL_PARSING_PARSER_MAP_LIKE_HPP_
 
 #include <map>
-#include <stdexcept>
 #include <string>
-#include <type_traits>
 #include <unordered_map>
 
 #include "../ExtraFields.hpp"
diff --git a/include/rfl/parsing/Parser_pair.hpp b/include/rfl/parsing/Parser_pair.hpp
index 6559a474..adf463f1 100644
--- a/include/rfl/parsing/Parser_pair.hpp
+++ b/include/rfl/parsing/Parser_pair.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_PARSER_PAIR_HPP_
 
 #include <map>
-#include <type_traits>
 #include <utility>
 
 #include "../Ref.hpp"
diff --git a/include/rfl/parsing/Parser_rfl_array.hpp b/include/rfl/parsing/Parser_rfl_array.hpp
index 1c6d9a73..f0660a88 100644
--- a/include/rfl/parsing/Parser_rfl_array.hpp
+++ b/include/rfl/parsing/Parser_rfl_array.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_PARSER_RFL_ARRAY_HPP_
 
 #include <map>
-#include <type_traits>
 
 #include "../Result.hpp"
 #include "../always_false.hpp"
diff --git a/include/rfl/parsing/Parser_rfl_variant.hpp b/include/rfl/parsing/Parser_rfl_variant.hpp
index 1e7dc7d3..d0f698bd 100644
--- a/include/rfl/parsing/Parser_rfl_variant.hpp
+++ b/include/rfl/parsing/Parser_rfl_variant.hpp
@@ -3,12 +3,12 @@
 
 #include <map>
 #include <type_traits>
-#include <variant>
 
 #include "../Result.hpp"
 #include "../Variant.hpp"
 #include "../always_false.hpp"
 #include "../internal/nth_element_t.hpp"
+#include "../internal/all_fields.hpp"
 #include "FieldVariantParser.hpp"
 #include "Parser_base.hpp"
 #include "VariantAlternativeWrapper.hpp"
diff --git a/include/rfl/parsing/Parser_string_view.hpp b/include/rfl/parsing/Parser_string_view.hpp
index 492a3201..62e5db43 100644
--- a/include/rfl/parsing/Parser_string_view.hpp
+++ b/include/rfl/parsing/Parser_string_view.hpp
@@ -5,7 +5,6 @@
 #include <map>
 #include <string>
 #include <string_view>
-#include <type_traits>
 
 #include "../Result.hpp"
 #include "../always_false.hpp"
diff --git a/include/rfl/parsing/Parser_variant.hpp b/include/rfl/parsing/Parser_variant.hpp
index d424ee61..159e65aa 100644
--- a/include/rfl/parsing/Parser_variant.hpp
+++ b/include/rfl/parsing/Parser_variant.hpp
@@ -21,6 +21,8 @@
 #include "schemaful/IsSchemafulWriter.hpp"
 #include "schemaful/VariantReader.hpp"
 #include "to_single_error_message.hpp"
+#include "../internal/all_fields.hpp"
+
 
 namespace rfl::parsing {
 
diff --git a/include/rfl/parsing/Parser_vector_like.hpp b/include/rfl/parsing/Parser_vector_like.hpp
index a18e3ba4..81412156 100644
--- a/include/rfl/parsing/Parser_vector_like.hpp
+++ b/include/rfl/parsing/Parser_vector_like.hpp
@@ -6,9 +6,6 @@
 #include <list>
 #include <map>
 #include <set>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
diff --git a/include/rfl/parsing/Parser_wstring.hpp b/include/rfl/parsing/Parser_wstring.hpp
index 1f3a8339..e8441b18 100644
--- a/include/rfl/parsing/Parser_wstring.hpp
+++ b/include/rfl/parsing/Parser_wstring.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_PARSER_WSTRING_HPP_
 
 #include <map>
-#include <type_traits>
 
 #include "../Result.hpp"
 #include "../always_false.hpp"
diff --git a/include/rfl/parsing/SupportsTaggedUnions.hpp b/include/rfl/parsing/SupportsTaggedUnions.hpp
index 5dc26c7e..971e41b2 100644
--- a/include/rfl/parsing/SupportsTaggedUnions.hpp
+++ b/include/rfl/parsing/SupportsTaggedUnions.hpp
@@ -1,13 +1,8 @@
 #ifndef RFL_PARSING_SUPPORTSTAGGEDUNIONS_HPP_
 #define RFL_PARSING_SUPPORTSTAGGEDUNIONS_HPP_
 
-#include <array>
 #include <concepts>
-#include <cstdint>
-#include <functional>
-#include <optional>
 #include <string>
-#include <string_view>
 
 #include "../Result.hpp"
 #include "../internal/is_basic_type.hpp"
diff --git a/include/rfl/parsing/TaggedUnionWrapper.hpp b/include/rfl/parsing/TaggedUnionWrapper.hpp
index cdc45de9..feffceea 100644
--- a/include/rfl/parsing/TaggedUnionWrapper.hpp
+++ b/include/rfl/parsing/TaggedUnionWrapper.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_PARSING_TAGGEDUNIONWRAPPER_HPP_
 #define RFL_PARSING_TAGGEDUNIONWRAPPER_HPP_
 
-#include <string>
 #include <type_traits>
 
 #include "../Flatten.hpp"
diff --git a/include/rfl/parsing/TupleReader.hpp b/include/rfl/parsing/TupleReader.hpp
index 6883a9c4..0a5f5dc1 100644
--- a/include/rfl/parsing/TupleReader.hpp
+++ b/include/rfl/parsing/TupleReader.hpp
@@ -2,10 +2,7 @@
 #define RFL_PARSING_TUPLEREADER_HPP_
 
 #include <sstream>
-#include <string_view>
-#include <tuple>
 #include <type_traits>
-#include <vector>
 
 #include "../Result.hpp"
 #include "../Tuple.hpp"
diff --git a/include/rfl/parsing/VectorParser.hpp b/include/rfl/parsing/VectorParser.hpp
index 2c92762d..7f83c61e 100644
--- a/include/rfl/parsing/VectorParser.hpp
+++ b/include/rfl/parsing/VectorParser.hpp
@@ -3,7 +3,6 @@
 
 #include <iterator>
 #include <map>
-#include <stdexcept>
 #include <string>
 #include <type_traits>
 
diff --git a/include/rfl/parsing/ViewReaderWithDefaultAndStrippedFieldNames.hpp b/include/rfl/parsing/ViewReaderWithDefaultAndStrippedFieldNames.hpp
index 1bb2e67f..e93018ee 100644
--- a/include/rfl/parsing/ViewReaderWithDefaultAndStrippedFieldNames.hpp
+++ b/include/rfl/parsing/ViewReaderWithDefaultAndStrippedFieldNames.hpp
@@ -1,9 +1,7 @@
 #ifndef RFL_PARSING_VIEWREADERWITHDEFAULTANDSTRIPPEDFIELDNAMES_HPP_
 #define RFL_PARSING_VIEWREADERWITHDEFAULTANDSTRIPPEDFIELDNAMES_HPP_
 
-#include <array>
 #include <sstream>
-#include <string_view>
 #include <type_traits>
 #include <utility>
 #include <vector>
diff --git a/include/rfl/parsing/ViewReaderWithStrippedFieldNames.hpp b/include/rfl/parsing/ViewReaderWithStrippedFieldNames.hpp
index e438e40d..c4ab784d 100644
--- a/include/rfl/parsing/ViewReaderWithStrippedFieldNames.hpp
+++ b/include/rfl/parsing/ViewReaderWithStrippedFieldNames.hpp
@@ -3,7 +3,6 @@
 
 #include <array>
 #include <sstream>
-#include <string_view>
 #include <type_traits>
 #include <utility>
 #include <vector>
diff --git a/include/rfl/parsing/call_destructors_on_tuple_where_necessary.hpp b/include/rfl/parsing/call_destructors_on_tuple_where_necessary.hpp
index 77d7e991..88004a0d 100644
--- a/include/rfl/parsing/call_destructors_on_tuple_where_necessary.hpp
+++ b/include/rfl/parsing/call_destructors_on_tuple_where_necessary.hpp
@@ -1,7 +1,6 @@
 #ifndef RFL_PARSING_CALL_DESTRUCTORS_ON_TUPLE_WHERE_NECESSARY_HPP_
 #define RFL_PARSING_CALL_DESTRUCTORS_ON_TUPLE_WHERE_NECESSARY_HPP_
 
-#include <array>
 #include <type_traits>
 
 #include "../Tuple.hpp"
diff --git a/include/rfl/parsing/is_vector_like.hpp b/include/rfl/parsing/is_vector_like.hpp
index 6cf78085..d48bee44 100644
--- a/include/rfl/parsing/is_vector_like.hpp
+++ b/include/rfl/parsing/is_vector_like.hpp
@@ -5,8 +5,6 @@
 #include <forward_list>
 #include <list>
 #include <set>
-#include <string>
-#include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
diff --git a/include/rfl/parsing/schema/ValidationType.hpp b/include/rfl/parsing/schema/ValidationType.hpp
index dab04df5..b6da3126 100644
--- a/include/rfl/parsing/schema/ValidationType.hpp
+++ b/include/rfl/parsing/schema/ValidationType.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_PARSING_SCHEMA_VALIDATIONTYPE_HPP_
 #define RFL_PARSING_SCHEMA_VALIDATIONTYPE_HPP_
 
-#include <cstddef>
-#include <map>
 #include <string>
 #include <vector>
 
diff --git a/include/rfl/parsing/schemaful/IsSchemafulWriter.hpp b/include/rfl/parsing/schemaful/IsSchemafulWriter.hpp
index e19debb3..68076838 100644
--- a/include/rfl/parsing/schemaful/IsSchemafulWriter.hpp
+++ b/include/rfl/parsing/schemaful/IsSchemafulWriter.hpp
@@ -4,7 +4,6 @@
 #include <concepts>
 #include <string>
 #include <string_view>
-#include <variant>
 
 namespace rfl::parsing::schemaful {
 
diff --git a/include/rfl/parsing/schemaful/tuple_to_named_tuple_t.hpp b/include/rfl/parsing/schemaful/tuple_to_named_tuple_t.hpp
index 3b369b33..3d66c371 100644
--- a/include/rfl/parsing/schemaful/tuple_to_named_tuple_t.hpp
+++ b/include/rfl/parsing/schemaful/tuple_to_named_tuple_t.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_SCHEMAFUL_TUPLETONAMEDTUPLE_T_HPP_
 
 #include <tuple>
-#include <type_traits>
 #include <utility>
 
 #include "../../NamedTuple.hpp"
diff --git a/include/rfl/parsing/schemaful/tuple_to_object.hpp b/include/rfl/parsing/schemaful/tuple_to_object.hpp
index b01da602..a8f8a2dc 100644
--- a/include/rfl/parsing/schemaful/tuple_to_object.hpp
+++ b/include/rfl/parsing/schemaful/tuple_to_object.hpp
@@ -1,8 +1,6 @@
 #ifndef RFL_PARSING_SCHEMAFUL_TUPLETOOBJECT_HPP_
 #define RFL_PARSING_SCHEMAFUL_TUPLETOOBJECT_HPP_
 
-#include <string>
-
 #include "../schema/Type.hpp"
 
 namespace rfl::parsing::schemaful {
diff --git a/include/rfl/parsing/supports_attributes.hpp b/include/rfl/parsing/supports_attributes.hpp
index b00569df..a6a2bdb2 100644
--- a/include/rfl/parsing/supports_attributes.hpp
+++ b/include/rfl/parsing/supports_attributes.hpp
@@ -2,7 +2,6 @@
 #define RFL_PARSING_SUPPORTSATTRIBUTES_HPP_
 
 #include <concepts>
-#include <string>
 #include <string_view>
 
 #include "../Result.hpp"
diff --git a/include/rfl/parsing/tabular/ArrowReader.hpp b/include/rfl/parsing/tabular/ArrowReader.hpp
index d749ae74..d281608c 100644
--- a/include/rfl/parsing/tabular/ArrowReader.hpp
+++ b/include/rfl/parsing/tabular/ArrowReader.hpp
@@ -4,7 +4,6 @@
 #include <arrow/api.h>
 
 #include <array>
-#include <memory>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
diff --git a/include/rfl/parsing/tabular/ArrowTypes.hpp b/include/rfl/parsing/tabular/ArrowTypes.hpp
index 26acc3fc..62818554 100644
--- a/include/rfl/parsing/tabular/ArrowTypes.hpp
+++ b/include/rfl/parsing/tabular/ArrowTypes.hpp
@@ -3,13 +3,10 @@
 
 #include <arrow/api.h>
 
-#include <array>
-#include <cinttypes>
 #include <memory>
 #include <optional>
 #include <stdexcept>
 #include <string>
-#include <type_traits>
 
 #include "../../Box.hpp"
 #include "../../NamedTuple.hpp"
diff --git a/include/rfl/parsing/tabular/ArrowWriter.hpp b/include/rfl/parsing/tabular/ArrowWriter.hpp
index 476f5f48..fbe1444d 100644
--- a/include/rfl/parsing/tabular/ArrowWriter.hpp
+++ b/include/rfl/parsing/tabular/ArrowWriter.hpp
@@ -3,7 +3,6 @@
 
 #include <arrow/api.h>
 
-#include <memory>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
diff --git a/include/rfl/parsing/tabular/ChunkedArrayIterator.hpp b/include/rfl/parsing/tabular/ChunkedArrayIterator.hpp
index 776756ea..b29a2723 100644
--- a/include/rfl/parsing/tabular/ChunkedArrayIterator.hpp
+++ b/include/rfl/parsing/tabular/ChunkedArrayIterator.hpp
@@ -3,11 +3,6 @@
 
 #include <arrow/api.h>
 
-#include <memory>
-#include <stdexcept>
-#include <type_traits>
-#include <utility>
-
 #include "../../Ref.hpp"
 #include "../../Result.hpp"
 #include "../../internal/ptr_cast.hpp"
diff --git a/include/rfl/parsing/tabular/make_arrow_builders.hpp b/include/rfl/parsing/tabular/make_arrow_builders.hpp
index 33955f34..1ab8e506 100644
--- a/include/rfl/parsing/tabular/make_arrow_builders.hpp
+++ b/include/rfl/parsing/tabular/make_arrow_builders.hpp
@@ -3,12 +3,6 @@
 
 #include <arrow/api.h>
 
-#include <array>
-#include <cinttypes>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <string>
 #include <type_traits>
 
 #include "../../named_tuple_t.hpp"
diff --git a/include/rfl/parsing/tabular/make_chunked_array_iterators.hpp b/include/rfl/parsing/tabular/make_chunked_array_iterators.hpp
index 3bd6dc9e..bf65dffb 100644
--- a/include/rfl/parsing/tabular/make_chunked_array_iterators.hpp
+++ b/include/rfl/parsing/tabular/make_chunked_array_iterators.hpp
@@ -3,13 +3,7 @@
 
 #include <arrow/api.h>
 
-#include <array>
-#include <cinttypes>
-#include <memory>
-#include <optional>
-#include <stdexcept>
 #include <string>
-#include <type_traits>
 
 #include "../../NamedTuple.hpp"
 #include "../../Ref.hpp"
diff --git a/include/rfl/thirdparty/enchantum/common.hpp b/include/rfl/thirdparty/enchantum/common.hpp
index 4f9df168..6c805aa5 100644
--- a/include/rfl/thirdparty/enchantum/common.hpp
+++ b/include/rfl/thirdparty/enchantum/common.hpp
@@ -1,7 +1,6 @@
 #pragma once
 #include <concepts>
 #include <limits>
-#include <string_view>
 #include <type_traits>
 
 #ifndef ENCHANTUM_ASSERT
diff --git a/include/rfl/thirdparty/enchantum/details/enchantum_clang.hpp b/include/rfl/thirdparty/enchantum/details/enchantum_clang.hpp
index 7713c0d0..47655606 100644
--- a/include/rfl/thirdparty/enchantum/details/enchantum_clang.hpp
+++ b/include/rfl/thirdparty/enchantum/details/enchantum_clang.hpp
@@ -9,7 +9,6 @@
 #include "string_view.hpp"
 #include <array>
 #include <cassert>
-#include <climits>
 #include <type_traits>
 #include <utility>
 
diff --git a/include/rfl/thirdparty/enchantum/details/enchantum_gcc.hpp b/include/rfl/thirdparty/enchantum/details/enchantum_gcc.hpp
index efc0bb0f..b622a15f 100644
--- a/include/rfl/thirdparty/enchantum/details/enchantum_gcc.hpp
+++ b/include/rfl/thirdparty/enchantum/details/enchantum_gcc.hpp
@@ -2,8 +2,6 @@
 #include "generate_arrays.hpp"
 #include <array>
 #include <cassert>
-#include <climits>
-#include <type_traits>
 #include <utility>
 
 #include "string_view.hpp"
diff --git a/include/rfl/thirdparty/enchantum/details/enchantum_msvc.hpp b/include/rfl/thirdparty/enchantum/details/enchantum_msvc.hpp
index dc4b77ab..a72e3193 100644
--- a/include/rfl/thirdparty/enchantum/details/enchantum_msvc.hpp
+++ b/include/rfl/thirdparty/enchantum/details/enchantum_msvc.hpp
@@ -4,9 +4,6 @@
 #include "string_view.hpp"
 #include <array>
 #include <cassert>
-#include <climits>
-#include <type_traits>
-#include <utility>
 
 namespace enchantum {
 
diff --git a/include/rfl/thirdparty/enchantum/enchantum.hpp b/include/rfl/thirdparty/enchantum/enchantum.hpp
index 63482ce6..6f11b595 100644
--- a/include/rfl/thirdparty/enchantum/enchantum.hpp
+++ b/include/rfl/thirdparty/enchantum/enchantum.hpp
@@ -5,7 +5,6 @@
 #include "details/string_view.hpp"
 #include "entries.hpp"
 #include <type_traits>
-#include <utility>
 
 namespace enchantum {
 
diff --git a/include/rfl/thirdparty/enchantum/fmt_format.hpp b/include/rfl/thirdparty/enchantum/fmt_format.hpp
index 06d9615e..6c2c4efa 100644
--- a/include/rfl/thirdparty/enchantum/fmt_format.hpp
+++ b/include/rfl/thirdparty/enchantum/fmt_format.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "bitflags.hpp"
 #include "details/format_util.hpp"
 #include "enchantum.hpp"
 #include <fmt/format.h>
diff --git a/include/rfl/thirdparty/enchantum/ostream.hpp b/include/rfl/thirdparty/enchantum/ostream.hpp
index 0d69acfa..2d76ccdb 100644
--- a/include/rfl/thirdparty/enchantum/ostream.hpp
+++ b/include/rfl/thirdparty/enchantum/ostream.hpp
@@ -2,7 +2,6 @@
 
 #include "enchantum.hpp"
 #include <iosfwd>
-#include <string_view>
 #include "details/format_util.hpp"
 
 namespace enchantum::ostream_operators {
diff --git a/include/rfl/thirdparty/enchantum/std_format.hpp b/include/rfl/thirdparty/enchantum/std_format.hpp
index 9c2b9e5e..43b54f03 100644
--- a/include/rfl/thirdparty/enchantum/std_format.hpp
+++ b/include/rfl/thirdparty/enchantum/std_format.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "bitflags.hpp"
 #include "enchantum.hpp"
 
 #include <format>
diff --git a/include/rfl/toml/Writer.hpp b/include/rfl/toml/Writer.hpp
index e53c96b4..09bc9bc3 100644
--- a/include/rfl/toml/Writer.hpp
+++ b/include/rfl/toml/Writer.hpp
@@ -1,10 +1,7 @@
 #ifndef RFL_TOML_WRITER_HPP_
 #define RFL_TOML_WRITER_HPP_
 
-#include <exception>
 #include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <toml++/toml.hpp>
diff --git a/include/rfl/ubjson/Writer.hpp b/include/rfl/ubjson/Writer.hpp
index 4208e611..752226c7 100644
--- a/include/rfl/ubjson/Writer.hpp
+++ b/include/rfl/ubjson/Writer.hpp
@@ -2,11 +2,8 @@
 #define RFL_UBJSON_WRITER_HPP_
 
 #include <bit>
-#include <exception>
 #include <jsoncons_ext/ubjson/ubjson_encoder.hpp>
 #include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
diff --git a/include/rfl/yaml/Writer.hpp b/include/rfl/yaml/Writer.hpp
index 7ad1aacb..ae9d6ba4 100644
--- a/include/rfl/yaml/Writer.hpp
+++ b/include/rfl/yaml/Writer.hpp
@@ -3,17 +3,11 @@
 
 #include <yaml-cpp/yaml.h>
 
-#include <exception>
-#include <map>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <vector>
 
 #include "../Ref.hpp"
-#include "../Result.hpp"
 #include "../always_false.hpp"
 
 namespace rfl {
diff --git a/src/rfl/avro/Writer.cpp b/src/rfl/avro/Writer.cpp
index 45ef4f71..09846f32 100644
--- a/src/rfl/avro/Writer.cpp
+++ b/src/rfl/avro/Writer.cpp
@@ -1,4 +1,5 @@
 #include "rfl/avro/Writer.hpp"
+#include <string_view>
 
 #include "rfl/parsing/schemaful/IsSchemafulWriter.hpp"
 
@@ -12,21 +13,24 @@ Writer::Writer(avro_value_t* _root) : root_(_root){};
 Writer::~Writer() = default;
 
 Writer::OutputArrayType Writer::array_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return OutputArrayType{*root_};
 }
 
-Writer::OutputMapType Writer::map_as_root(const size_t _size) const noexcept {
+Writer::OutputMapType Writer::map_as_root(const size_t /*_size*/) const noexcept {
   return OutputMapType{*root_};
 }
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return OutputObjectType{*root_};
 }
 
-Writer::OutputVarType Writer::null_as_root() const noexcept {
-  avro_value_set_null(root_);
+Writer::OutputVarType Writer::null_as_root() const {
+  int result = avro_value_set_null(root_);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputVarType{*root_};
 }
 
@@ -35,155 +39,227 @@ Writer::OutputUnionType Writer::union_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const {
   avro_value_t new_array;
-  avro_value_append(&_parent->val_, &new_array, nullptr);
+  int result = avro_value_append(&_parent->val_, &new_array, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputArrayType{new_array};
 }
 
 Writer::OutputArrayType Writer::add_array_to_map(
-    const std::string_view& _name, const size_t _size,
-    OutputMapType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputMapType* _parent) const {
   avro_value_t new_array;
-  avro_value_add(&_parent->val_, _name.data(), &new_array, nullptr, nullptr);
+  int result = avro_value_add(&_parent->val_, _name.data(), &new_array, nullptr, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputArrayType{new_array};
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
-    const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputObjectType* _parent) const {
   avro_value_t new_array;
-  avro_value_get_by_name(&_parent->val_, _name.data(), &new_array, nullptr);
+  int result = avro_value_get_by_name(&_parent->val_, _name.data(), &new_array, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputArrayType{new_array};
 }
 
 Writer::OutputArrayType Writer::add_array_to_union(
-    const size_t _index, const size_t _size,
-    OutputUnionType* _parent) const noexcept {
+    const size_t _index, const size_t /*_size*/,
+    OutputUnionType* _parent) const {
   avro_value_t new_array;
-  avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_array);
+  int result = avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_array);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputArrayType{new_array};
 }
 
 Writer::OutputMapType Writer::add_map_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const {
   avro_value_t new_map;
-  avro_value_append(&_parent->val_, &new_map, nullptr);
+  int result = avro_value_append(&_parent->val_, &new_map, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputMapType{new_map};
 }
 
 Writer::OutputMapType Writer::add_map_to_map(
-    const std::string_view& _name, const size_t _size,
-    OutputMapType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputMapType* _parent) const {
   avro_value_t new_map;
-  avro_value_add(&_parent->val_, _name.data(), &new_map, nullptr, nullptr);
+  int result = avro_value_add(&_parent->val_, _name.data(), &new_map, nullptr, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputMapType{new_map};
 }
 
 Writer::OutputMapType Writer::add_map_to_object(
-    const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputObjectType* _parent) const {
   avro_value_t new_map;
-  avro_value_get_by_name(&_parent->val_, _name.data(), &new_map, nullptr);
+  int result = avro_value_get_by_name(&_parent->val_, _name.data(), &new_map, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputMapType{new_map};
 }
 
 Writer::OutputMapType Writer::add_map_to_union(
-    const size_t _index, const size_t _size,
-    OutputUnionType* _parent) const noexcept {
+    const size_t _index, const size_t /*_size*/,
+    OutputUnionType* _parent) const {
   avro_value_t new_map;
-  avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_map);
+  int result = avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_map);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputMapType{new_map};
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const {
   avro_value_t new_object;
-  avro_value_append(&_parent->val_, &new_object, nullptr);
+  int result = avro_value_append(&_parent->val_, &new_object, nullptr);
+    if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputObjectType{new_object};
 }
 
 Writer::OutputObjectType Writer::add_object_to_map(
-    const std::string_view& _name, const size_t _size,
-    OutputMapType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputMapType* _parent) const {
   avro_value_t new_object;
-  avro_value_add(&_parent->val_, _name.data(), &new_object, nullptr, nullptr);
+  int result = avro_value_add(&_parent->val_, _name.data(), &new_object, nullptr, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputObjectType{new_object};
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputObjectType* _parent) const {
   avro_value_t new_object;
-  avro_value_get_by_name(&_parent->val_, _name.data(), &new_object, nullptr);
+  int result = avro_value_get_by_name(&_parent->val_, _name.data(), &new_object, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputObjectType{new_object};
 }
 
 Writer::OutputObjectType Writer::add_object_to_union(
-    const size_t _index, const size_t _size,
-    OutputUnionType* _parent) const noexcept {
+    const size_t _index, const size_t /*_size*/,
+    OutputUnionType* _parent) const {
   avro_value_t new_object;
-  avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_object);
+  int result = avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_object);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputObjectType{new_object};
 }
 
 Writer::OutputUnionType Writer::add_union_to_array(
-    OutputArrayType* _parent) const noexcept {
+    OutputArrayType* _parent) const {
   avro_value_t new_union;
-  avro_value_append(&_parent->val_, &new_union, nullptr);
+  int result = avro_value_append(&_parent->val_, &new_union, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputUnionType{new_union};
 }
 
 Writer::OutputUnionType Writer::add_union_to_map(
-    const std::string_view& _name, OutputMapType* _parent) const noexcept {
+    const std::string_view& _name, OutputMapType* _parent) const {
   avro_value_t new_union;
-  avro_value_add(&_parent->val_, _name.data(), &new_union, nullptr, nullptr);
+  int result = avro_value_add(&_parent->val_, _name.data(), &new_union, nullptr, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputUnionType{new_union};
 }
 
 Writer::OutputUnionType Writer::add_union_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, OutputObjectType* _parent) const {
   avro_value_t new_union;
-  avro_value_get_by_name(&_parent->val_, _name.data(), &new_union, nullptr);
+  int result = avro_value_get_by_name(&_parent->val_, _name.data(), &new_union, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputUnionType{new_union};
 }
 
 Writer::OutputUnionType Writer::add_union_to_union(
-    const size_t _index, OutputUnionType* _parent) const noexcept {
+    const size_t _index, OutputUnionType* _parent) const {
   avro_value_t new_union;
-  avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_union);
+  int result = avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_union);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputUnionType{new_union};
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
-    OutputArrayType* _parent) const noexcept {
+    OutputArrayType* _parent) const {
   avro_value_t new_null;
-  avro_value_append(&_parent->val_, &new_null, nullptr);
-  avro_value_set_null(&new_null);
+  int result = avro_value_append(&_parent->val_, &new_null, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
+  result = avro_value_set_null(&new_null);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputVarType{new_null};
 }
 
 Writer::OutputVarType Writer::add_null_to_map(
-    const std::string_view& _name, OutputMapType* _parent) const noexcept {
+    const std::string_view& _name, OutputMapType* _parent) const {
   avro_value_t new_null;
-  avro_value_add(&_parent->val_, _name.data(), &new_null, nullptr, nullptr);
-  avro_value_set_null(&new_null);
+  int result = avro_value_add(&_parent->val_, _name.data(), &new_null, nullptr, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
+  result = avro_value_set_null(&new_null);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputVarType{new_null};
 }
 
 Writer::OutputVarType Writer::add_null_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, OutputObjectType* _parent) const {
   avro_value_t new_null;
-  avro_value_get_by_name(&_parent->val_, _name.data(), &new_null, nullptr);
-  avro_value_set_null(&new_null);
+  int result = avro_value_get_by_name(&_parent->val_, _name.data(), &new_null, nullptr);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
+  result = avro_value_set_null(&new_null);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputVarType{new_null};
 }
 
 Writer::OutputVarType Writer::add_null_to_union(
-    const size_t _index, OutputUnionType* _parent) const noexcept {
+    const size_t _index, OutputUnionType* _parent) const {
   avro_value_t new_null;
-  avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_null);
-  avro_value_set_null(&new_null);
+  int result = avro_value_set_branch(&_parent->val_, static_cast<int>(_index), &new_null);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
+  result = avro_value_set_null(&new_null);
+  if (result != 0) {
+    throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): "  + avro_strerror());
+  }
   return OutputVarType{new_null};
 }
 
diff --git a/src/rfl/bson/Writer.cpp b/src/rfl/bson/Writer.cpp
index a5355664..adf124c8 100644
--- a/src/rfl/bson/Writer.cpp
+++ b/src/rfl/bson/Writer.cpp
@@ -7,13 +7,13 @@ Writer::Writer(bson_t* _doc) : doc_(_doc) {}
 Writer::~Writer() = default;
 
 Writer::OutputArrayType Writer::array_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   bson_array_builder_t* val = bson_array_builder_new();
   return OutputArrayType(val, IsRoot{});
 }
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return OutputObjectType(doc_, IsRoot{});
 }
 
@@ -23,14 +23,14 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   bson_array_builder_t* val;
   bson_array_builder_append_array_builder_begin(_parent->val_, &val);
   return OutputArrayType(val, IsArray{_parent->val_});
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   bson_array_builder_t* val;
   bson_append_array_builder_begin(_parent->val_, _name.data(),
@@ -39,7 +39,7 @@ Writer::OutputArrayType Writer::add_array_to_object(
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   subdocs_->emplace_back(rfl::Box<BSONType>());
   bson_array_builder_append_document_begin(_parent->val_,
                                            &(subdocs_->back()->val_));
@@ -47,7 +47,7 @@ Writer::OutputObjectType Writer::add_object_to_array(
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   subdocs_->emplace_back(rfl::Box<BSONType>());
   bson_append_document_begin(_parent->val_, _name.data(),
diff --git a/src/rfl/capnproto/Writer.cpp b/src/rfl/capnproto/Writer.cpp
index cf575a1d..ea4fc53a 100644
--- a/src/rfl/capnproto/Writer.cpp
+++ b/src/rfl/capnproto/Writer.cpp
@@ -9,19 +9,27 @@ namespace rfl::capnproto {
 static_assert(parsing::schemaful::IsSchemafulWriter<Writer>,
               "This must be a schemaful writer.");
 
+
+inline unsigned int SafeSizeToUInt(size_t sizeValue) {
+  if (sizeValue > static_cast<size_t>(std::numeric_limits<unsigned int>::max())) {
+    throw std::overflow_error("size_t value is too big to fit into an unsigned int.");
+  }
+  return static_cast<unsigned int>(sizeValue);
+}
+
 Writer::Writer(capnp::DynamicStruct::Builder* _root) : root_(_root){};
 
 Writer::~Writer() = default;
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return OutputObjectType{root_->as<capnp::DynamicStruct>()};
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
     const size_t _size, OutputArrayType* _parent) const noexcept {
   return OutputArrayType{
-      _parent->val_.init(_parent->ix_++, _size).as<capnp::DynamicList>()};
+      _parent->val_.init(SafeSizeToUInt(_parent->ix_++), SafeSizeToUInt(_size)).as<capnp::DynamicList>()};
 }
 
 Writer::OutputArrayType Writer::add_array_to_map(
@@ -39,15 +47,16 @@ Writer::OutputArrayType Writer::add_array_to_object(
     const std::string_view& _name, const size_t _size,
     OutputObjectType* _parent) const noexcept {
   return OutputArrayType{
-      _parent->val_.init(_name.data(), _size).as<capnp::DynamicList>()};
+      _parent->val_.init(_name.data(), SafeSizeToUInt(_size)).as<capnp::DynamicList>()};
 }
 
 Writer::OutputArrayType Writer::add_array_to_union(
     const size_t _index, const size_t _size,
     OutputUnionType* _parent) const noexcept {
-  const auto field = _parent->val_.getSchema().getFields()[_index];
+
+  const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)];
   return OutputArrayType{
-      _parent->val_.init(field, _size).template as<capnp::DynamicList>()};
+      _parent->val_.init(field, SafeSizeToUInt(_size)).template as<capnp::DynamicList>()};
 }
 
 Writer::OutputMapType Writer::add_map_to_array(
@@ -82,9 +91,9 @@ Writer::OutputMapType Writer::add_map_to_union(
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   return OutputObjectType{
-      _parent->val_[_parent->ix_++].as<capnp::DynamicStruct>()};
+      _parent->val_[SafeSizeToUInt(_parent->ix_++)].as<capnp::DynamicStruct>()};
 }
 
 Writer::OutputObjectType Writer::add_object_to_map(
@@ -99,16 +108,16 @@ Writer::OutputObjectType Writer::add_object_to_map(
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   return OutputObjectType{
       _parent->val_.get(_name.data()).as<capnp::DynamicStruct>()};
 }
 
 Writer::OutputObjectType Writer::add_object_to_union(
-    const size_t _index, const size_t _size,
+    const size_t _index, const size_t /*_size*/,
     OutputUnionType* _parent) const noexcept {
-  const auto field = _parent->val_.getSchema().getFields()[_index];
+  const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)];
   return OutputObjectType{
       _parent->val_.init(field).template as<capnp::DynamicStruct>()};
 }
@@ -116,7 +125,7 @@ Writer::OutputObjectType Writer::add_object_to_union(
 Writer::OutputUnionType Writer::add_union_to_array(
     OutputArrayType* _parent) const noexcept {
   return OutputUnionType{
-      _parent->val_[_parent->ix_++].as<capnp::DynamicStruct>()};
+      _parent->val_[SafeSizeToUInt(_parent->ix_++)].as<capnp::DynamicStruct>()};
 }
 
 Writer::OutputUnionType Writer::add_union_to_map(
@@ -137,14 +146,14 @@ Writer::OutputUnionType Writer::add_union_to_object(
 
 Writer::OutputUnionType Writer::add_union_to_union(
     const size_t _index, OutputUnionType* _parent) const noexcept {
-  const auto field = _parent->val_.getSchema().getFields()[_index];
+  const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)];
   return OutputUnionType{
       _parent->val_.init(field).template as<capnp::DynamicStruct>()};
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
     OutputArrayType* _parent) const noexcept {
-  _parent->val_.set(_parent->ix_++, capnp::VOID);
+  _parent->val_.set(SafeSizeToUInt(_parent->ix_++), capnp::VOID);
   return OutputVarType{};
 }
 
@@ -166,7 +175,7 @@ Writer::OutputVarType Writer::add_null_to_object(
 
 Writer::OutputVarType Writer::add_null_to_union(
     const size_t _index, OutputUnionType* _parent) const noexcept {
-  const auto field = _parent->val_.getSchema().getFields()[_index];
+  const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)];
   _parent->val_.set(field, capnp::VOID);
   return OutputVarType{};
 }
diff --git a/src/rfl/capnproto/to_schema.cpp b/src/rfl/capnproto/to_schema.cpp
index dbef44c4..7b240323 100644
--- a/src/rfl/capnproto/to_schema.cpp
+++ b/src/rfl/capnproto/to_schema.cpp
@@ -26,7 +26,6 @@ SOFTWARE.
 
 #include "rfl/capnproto/to_schema.hpp"
 
-#include <iostream>
 #include <map>
 #include <sstream>
 #include <string>
@@ -34,8 +33,8 @@ SOFTWARE.
 #include "rfl/capnproto/is_named_type.hpp"
 #include "rfl/capnproto/schema/CapnProtoTypes.hpp"
 #include "rfl/capnproto/schema/Type.hpp"
-#include "rfl/internal/strings/strings.hpp"
-#include "rfl/json.hpp"
+//#include "rfl/internal/strings/strings.hpp"
+//#include "rfl/json.hpp"
 #include "rfl/parsing/schemaful/tuple_to_object.hpp"
 
 namespace rfl::capnproto {
@@ -71,7 +70,7 @@ schema::Type any_of_to_capnproto_schema_type(
 
 schema::Type literal_to_capnproto_schema_type(
     const parsing::schema::Type::Literal& _literal,
-    const std::map<std::string, parsing::schema::Type>& _definitions,
+    const std::map<std::string, parsing::schema::Type>& /*_definitions*/,
     const Parent _parent, schema::CapnProtoTypes* _cnp_types) {
   const auto enum_schema = schema::Type::Enum{.fields = _literal.values_};
   if (_parent == Parent::is_top_level) {
diff --git a/src/rfl/cbor/Writer.cpp b/src/rfl/cbor/Writer.cpp
index 8d5dfb18..72fe4bd6 100644
--- a/src/rfl/cbor/Writer.cpp
+++ b/src/rfl/cbor/Writer.cpp
@@ -22,47 +22,47 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t _size, OutputArrayType* /*_parent*/) const noexcept {
   return new_array(_size);
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
     const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* /*_parent*/) const noexcept {
   encoder_->key(_name);
   return new_array(_size);
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t, OutputArrayType* _parent) const noexcept {
+    const size_t, OutputArrayType* /*_parent*/) const noexcept {
   return new_object();
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
     const std::string_view& _name, const size_t,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* /*_parent*/) const noexcept {
   encoder_->key(_name);
   return new_object();
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
-    OutputArrayType* _parent) const noexcept {
+    OutputArrayType* /*_parent*/) const noexcept {
   encoder_->null_value();
   return OutputVarType{};
 }
 
 Writer::OutputVarType Writer::add_null_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept {
   encoder_->key(_name);
   encoder_->null_value();
   return OutputVarType{};
 }
 
-void Writer::end_array(OutputArrayType* _arr) const noexcept {
+void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {
   encoder_->end_array();
 }
 
-void Writer::end_object(OutputObjectType* _obj) const noexcept {
+void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {
   encoder_->end_object();
 }
 
diff --git a/src/rfl/flexbuf/Writer.cpp b/src/rfl/flexbuf/Writer.cpp
index 4be52ce8..5ca1ea2b 100644
--- a/src/rfl/flexbuf/Writer.cpp
+++ b/src/rfl/flexbuf/Writer.cpp
@@ -7,12 +7,12 @@ Writer::Writer(const Ref<flexbuffers::Builder>& _fbb) : fbb_(_fbb) {}
 Writer::~Writer() = default;
 
 Writer::OutputArrayType Writer::array_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return new_array();
 }
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return new_object();
 }
 
@@ -22,35 +22,35 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept {
   return new_array();
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
-    const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputObjectType* /*_parent*/) const noexcept {
   return new_array(_name);
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept {
   return new_object();
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputObjectType* /*_parent*/) const noexcept {
   return new_object(_name);
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
-    OutputArrayType* _parent) const noexcept {
+    OutputArrayType* /*_parent*/) const noexcept {
   fbb_->Null();
   return OutputVarType{};
 }
 
 Writer::OutputVarType Writer::add_null_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept {
   fbb_->Null(_name.data());
   return OutputVarType{};
 }
diff --git a/src/rfl/generic/Writer.cpp b/src/rfl/generic/Writer.cpp
index 4992ec6d..28672af8 100644
--- a/src/rfl/generic/Writer.cpp
+++ b/src/rfl/generic/Writer.cpp
@@ -29,13 +29,13 @@ SOFTWARE.
 namespace rfl::generic {
 
 Writer::OutputArrayType Writer::array_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   root_ = Generic::Array();
   return OutputArray{get_if<Generic::Array>(&root_.variant())};
 }
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   root_ = Generic::Object();
   return OutputObject{get_if<Generic::Object>(&root_.variant())};
 }
@@ -46,14 +46,14 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   _parent->val_->push_back(Generic(Generic::Array()));
   return OutputArrayType{
       get_if<Generic::Array>(&_parent->val_->rbegin()->variant())};
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   _parent->val_->insert(_name, Generic(Generic::Array()));
   return OutputArrayType{
@@ -61,14 +61,14 @@ Writer::OutputArrayType Writer::add_array_to_object(
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   _parent->val_->push_back(Generic(Generic::Object()));
   return OutputObjectType{
       get_if<Generic::Object>(&_parent->val_->rbegin()->variant())};
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   _parent->val_->insert(_name, Generic(Generic::Object()));
   return OutputObjectType{
diff --git a/src/rfl/json/to_schema.cpp b/src/rfl/json/to_schema.cpp
index c3dfd878..df27ac7f 100644
--- a/src/rfl/json/to_schema.cpp
+++ b/src/rfl/json/to_schema.cpp
@@ -25,6 +25,8 @@ SOFTWARE.
 */
 
 #include "rfl/json/to_schema.hpp"
+#include "rfl/json/schema/Type.hpp"
+#include "rfl/json/write.hpp"
 
 namespace rfl::json {
 
@@ -96,8 +98,8 @@ schema::Type handle_validation_type(
 
     } else if constexpr (std::is_same<T, ValidationType::Size>()) {
       auto t = type_to_json_schema_type(_type, _no_required);
-      const auto to_size = [](const auto _v) {
-        return static_cast<size_t>(_v);
+      const auto to_size = [](const auto _val) {
+        return static_cast<size_t>(_val);
       };
       auto handle_size_variant = [&](auto& _t, const auto& _size_limit) {
         using U = std::remove_cvref_t<decltype(_t)>;
diff --git a/src/rfl/msgpack/Writer.cpp b/src/rfl/msgpack/Writer.cpp
index f711a0f4..adac7383 100644
--- a/src/rfl/msgpack/Writer.cpp
+++ b/src/rfl/msgpack/Writer.cpp
@@ -22,48 +22,48 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t _size, OutputArrayType* /*_parent*/) const noexcept {
   return new_array(_size);
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
     const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* /*_parent*/) const noexcept {
   msgpack_pack_str(pk_, _name.size());
   msgpack_pack_str_body(pk_, _name.data(), _name.size());
   return new_array(_size);
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t _size, OutputArrayType* /*_parent*/) const noexcept {
   return new_object(_size);
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
     const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* /*_parent*/) const noexcept {
   msgpack_pack_str(pk_, _name.size());
   msgpack_pack_str_body(pk_, _name.data(), _name.size());
   return new_object(_size);
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
-    OutputArrayType* _parent) const noexcept {
+    OutputArrayType* /*_parent*/) const noexcept {
   msgpack_pack_nil(pk_);
   return OutputVarType{};
 }
 
 Writer::OutputVarType Writer::add_null_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept {
   msgpack_pack_str(pk_, _name.size());
   msgpack_pack_str_body(pk_, _name.data(), _name.size());
   msgpack_pack_nil(pk_);
   return OutputVarType{};
 }
 
-void Writer::end_array(OutputArrayType* _arr) const noexcept {}
+void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {}
 
-void Writer::end_object(OutputObjectType* _obj) const noexcept {}
+void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {}
 
 Writer::OutputArrayType Writer::new_array(const size_t _size) const noexcept {
   msgpack_pack_array(pk_, _size);
diff --git a/src/rfl/toml/Writer.cpp b/src/rfl/toml/Writer.cpp
index 22e19032..d76ee636 100644
--- a/src/rfl/toml/Writer.cpp
+++ b/src/rfl/toml/Writer.cpp
@@ -7,7 +7,7 @@ Writer::Writer(::toml::table* _root) : root_(_root) {}
 Writer::~Writer() = default;
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return OutputObjectType{root_};
 }
 
@@ -16,28 +16,28 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   const auto i = _parent->val_->size();
   _parent->val_->push_back(::toml::array());
   return OutputArrayType{_parent->val_->at(i).as_array()};
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   _parent->val_->emplace(_name, ::toml::array());
   return OutputArrayType{_parent->val_->at_path(_name).as_array()};
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   const auto i = _parent->val_->size();
   _parent->val_->push_back(::toml::table());
   return OutputObjectType{_parent->val_->at(i).as_table()};
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   _parent->val_->emplace(_name, ::toml::table());
   return OutputObjectType{_parent->val_->at_path(_name).as_table()};
@@ -55,8 +55,8 @@ Writer::OutputVarType Writer::add_null_to_object(
   return OutputVarType{};
 }
 
-void Writer::end_array(OutputArrayType* _arr) const noexcept {}
+void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {}
 
-void Writer::end_object(OutputObjectType* _obj) const noexcept {}
+void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {}
 
 }  // namespace rfl::toml
diff --git a/src/rfl/ubjson/Writer.cpp b/src/rfl/ubjson/Writer.cpp
index 278edca2..07c1790a 100644
--- a/src/rfl/ubjson/Writer.cpp
+++ b/src/rfl/ubjson/Writer.cpp
@@ -22,47 +22,47 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t _size, OutputArrayType* /*_parent*/) const noexcept {
   return new_array(_size);
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
     const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* /*_parent*/) const noexcept {
   encoder_->key(_name);
   return new_array(_size);
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t _size, OutputArrayType* /*_parent*/) const noexcept {
   return new_object(_size);
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
     const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* /*_parent*/) const noexcept {
   encoder_->key(_name);
   return new_object(_size);
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
-    OutputArrayType* _parent) const noexcept {
+    OutputArrayType* /*_parent*/) const noexcept {
   encoder_->null_value();
   return OutputVarType{};
 }
 
 Writer::OutputVarType Writer::add_null_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept {
   encoder_->key(_name);
   encoder_->null_value();
   return OutputVarType{};
 }
 
-void Writer::end_array(OutputArrayType* _arr) const noexcept {
+void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {
   encoder_->end_array();
 }
 
-void Writer::end_object(OutputObjectType* _obj) const noexcept {
+void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {
   encoder_->end_object();
 }
 
diff --git a/src/rfl/xml/Writer.cpp b/src/rfl/xml/Writer.cpp
index 8efbb4b2..f9612352 100644
--- a/src/rfl/xml/Writer.cpp
+++ b/src/rfl/xml/Writer.cpp
@@ -38,14 +38,14 @@ Writer::Writer(const Ref<pugi::xml_node>& _root, const std::string& _root_name)
 Writer::~Writer() = default;
 
 Writer::OutputArrayType Writer::array_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   auto node_child =
       Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
   return OutputArrayType(root_name_, node_child);
 }
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   auto node_child =
       Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
   return OutputObjectType(node_child);
@@ -66,12 +66,12 @@ Writer::OutputVarType Writer::value_as_root_impl(
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   return *_parent;
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   return OutputArrayType(_name, _parent->node_);
 }
@@ -102,14 +102,14 @@ Writer::OutputVarType Writer::add_value_to_object_impl(
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
   auto node_child =
       Ref<pugi::xml_node>::make(_parent->node_->append_child(_parent->name_));
   return OutputObjectType(node_child);
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
+    const std::string_view& _name, const size_t /*_size*/,
     OutputObjectType* _parent) const noexcept {
   auto node_child =
       Ref<pugi::xml_node>::make(_parent->node_->append_child(_name));
@@ -137,8 +137,8 @@ Writer::OutputVarType Writer::add_null_to_object(
   }
 }
 
-void Writer::end_array(OutputArrayType* _arr) const noexcept {}
+void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {}
 
-void Writer::end_object(OutputObjectType* _obj) const noexcept {}
+void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {}
 
 }  // namespace rfl::xml
diff --git a/src/rfl/yaml/Writer.cpp b/src/rfl/yaml/Writer.cpp
index 8482377f..3de75c28 100644
--- a/src/rfl/yaml/Writer.cpp
+++ b/src/rfl/yaml/Writer.cpp
@@ -7,12 +7,12 @@ Writer::Writer(const Ref<YAML::Emitter>& _out) : out_(_out) {}
 Writer::~Writer() = default;
 
 Writer::OutputArrayType Writer::array_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return new_array();
 }
 
 Writer::OutputObjectType Writer::object_as_root(
-    const size_t _size) const noexcept {
+    const size_t /*_size*/) const noexcept {
   return new_object();
 }
 
@@ -21,42 +21,42 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept {
   return new_array();
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
-    const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputObjectType* /*_parent*/) const noexcept {
   return new_array(_name);
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t _size, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept {
   return new_object();
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
-    const std::string_view& _name, const size_t _size,
-    OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, const size_t /*_size*/,
+    OutputObjectType* /*_parent*/) const noexcept {
   return new_object(_name);
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
-    OutputArrayType* _parent) const noexcept {
+    OutputArrayType* /*_parent*/) const noexcept {
   return insert_value(YAML::Null);
 }
 
 Writer::OutputVarType Writer::add_null_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
+    const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept {
   return insert_value(_name, YAML::Null);
 }
 
-void Writer::end_array(OutputArrayType* _arr) const noexcept {
+void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {
   (*out_) << YAML::EndSeq;
 }
 
-void Writer::end_object(OutputObjectType* _obj) const noexcept {
+void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {
   (*out_) << YAML::EndMap;
 }
 
diff --git a/tests/avro/test_add_struct_name.cpp b/tests/avro/test_add_struct_name.cpp
index faf4caaf..9059e189 100644
--- a/tests/avro/test_add_struct_name.cpp
+++ b/tests/avro/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
@@ -15,7 +14,7 @@ struct Person {
   rfl::Timestamp<"%Y-%m-%d"> birthday;
   Age age;
   rfl::Email email;
-  std::vector<Person> children;
+  std::vector<Person> children{};
 };
 
 TEST(avro, test_add_struct_name) {
diff --git a/tests/avro/test_array.cpp b/tests/avro/test_array.cpp
index 2958983d..1c23263a 100644
--- a/tests/avro/test_array.cpp
+++ b/tests/avro/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/avro.hpp>
 #include <string>
diff --git a/tests/avro/test_box.cpp b/tests/avro/test_box.cpp
index 529314f2..0fa7aa9f 100644
--- a/tests/avro/test_box.cpp
+++ b/tests/avro/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_bytestring.cpp b/tests/avro/test_bytestring.cpp
index 52f6172e..29fe59e8 100644
--- a/tests/avro/test_bytestring.cpp
+++ b/tests/avro/test_bytestring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_combined_processors.cpp b/tests/avro/test_combined_processors.cpp
index b7480cee..f794b94a 100644
--- a/tests/avro/test_combined_processors.cpp
+++ b/tests/avro/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/avro/test_custom_class1.cpp b/tests/avro/test_custom_class1.cpp
index 75b62332..9e9b5fae 100644
--- a/tests/avro/test_custom_class1.cpp
+++ b/tests/avro/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/avro/test_custom_class3.cpp b/tests/avro/test_custom_class3.cpp
index 6433ba17..ee68f209 100644
--- a/tests/avro/test_custom_class3.cpp
+++ b/tests/avro/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_custom_class4.cpp b/tests/avro/test_custom_class4.cpp
index afd507ce..831b86c0 100644
--- a/tests/avro/test_custom_class4.cpp
+++ b/tests/avro/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_default_values.cpp b/tests/avro/test_default_values.cpp
index 83094716..a2407b0e 100644
--- a/tests/avro/test_default_values.cpp
+++ b/tests/avro/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/avro/test_deque.cpp b/tests/avro/test_deque.cpp
index 78237357..8e65a47e 100644
--- a/tests/avro/test_deque.cpp
+++ b/tests/avro/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_enum.cpp b/tests/avro/test_enum.cpp
index 60b2e67d..18ad25a3 100644
--- a/tests/avro/test_enum.cpp
+++ b/tests/avro/test_enum.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_field_variant.cpp b/tests/avro/test_field_variant.cpp
index 1001fe67..d9760516 100644
--- a/tests/avro/test_field_variant.cpp
+++ b/tests/avro/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_field_variant_std.cpp b/tests/avro/test_field_variant_std.cpp
index 3424361c..f61dca50 100644
--- a/tests/avro/test_field_variant_std.cpp
+++ b/tests/avro/test_field_variant_std.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_flag_enum.cpp b/tests/avro/test_flag_enum.cpp
index 7e086a69..38a14d3e 100644
--- a/tests/avro/test_flag_enum.cpp
+++ b/tests/avro/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_flag_enum_with_int.cpp b/tests/avro/test_flag_enum_with_int.cpp
index 2dc0b5cf..3428f66d 100644
--- a/tests/avro/test_flag_enum_with_int.cpp
+++ b/tests/avro/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_flatten.cpp b/tests/avro/test_flatten.cpp
index c890ba84..46bc17af 100644
--- a/tests/avro/test_flatten.cpp
+++ b/tests/avro/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_flatten_anonymous.cpp b/tests/avro/test_flatten_anonymous.cpp
index bbb160dc..6cebe8e5 100644
--- a/tests/avro/test_flatten_anonymous.cpp
+++ b/tests/avro/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_forward_list.cpp b/tests/avro/test_forward_list.cpp
index ec831696..9e964779 100644
--- a/tests/avro/test_forward_list.cpp
+++ b/tests/avro/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_literal.cpp b/tests/avro/test_literal.cpp
index 9432b1fb..6a891e9a 100644
--- a/tests/avro/test_literal.cpp
+++ b/tests/avro/test_literal.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/avro/test_literal_map.cpp b/tests/avro/test_literal_map.cpp
index 9714d7ce..e6c408be 100644
--- a/tests/avro/test_literal_map.cpp
+++ b/tests/avro/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_map.cpp b/tests/avro/test_map.cpp
index 6b63322e..55e9cf5d 100644
--- a/tests/avro/test_map.cpp
+++ b/tests/avro/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/avro/test_map2.cpp b/tests/avro/test_map2.cpp
index 51f1afa9..bd50cfa3 100644
--- a/tests/avro/test_map2.cpp
+++ b/tests/avro/test_map2.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/avro/test_monster_example.cpp b/tests/avro/test_monster_example.cpp
index 19a8bbdc..3a0f7507 100644
--- a/tests/avro/test_monster_example.cpp
+++ b/tests/avro/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/avro/test_optional_fields.cpp b/tests/avro/test_optional_fields.cpp
index ef32c0a8..9b5b0a24 100644
--- a/tests/avro/test_optional_fields.cpp
+++ b/tests/avro/test_optional_fields.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/avro/test_readme_example.cpp b/tests/avro/test_readme_example.cpp
index 4a63f464..c33614d7 100644
--- a/tests/avro/test_readme_example.cpp
+++ b/tests/avro/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/avro/test_readme_example2.cpp b/tests/avro/test_readme_example2.cpp
index 69f8b8ed..135ca15b 100644
--- a/tests/avro/test_readme_example2.cpp
+++ b/tests/avro/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_readme_example3.cpp b/tests/avro/test_readme_example3.cpp
index 169f6aed..37903bfd 100644
--- a/tests/avro/test_readme_example3.cpp
+++ b/tests/avro/test_readme_example3.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/avro/test_ref.cpp b/tests/avro/test_ref.cpp
index a997193d..6d812cf0 100644
--- a/tests/avro/test_ref.cpp
+++ b/tests/avro/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_rfl_tuple.cpp b/tests/avro/test_rfl_tuple.cpp
index 85641ffc..f33a84ad 100644
--- a/tests/avro/test_rfl_tuple.cpp
+++ b/tests/avro/test_rfl_tuple.cpp
@@ -3,7 +3,6 @@
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <tuple>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_rfl_variant.cpp b/tests/avro/test_rfl_variant.cpp
index b5e516ac..d7b2090f 100644
--- a/tests/avro/test_rfl_variant.cpp
+++ b/tests/avro/test_rfl_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_save_load.cpp b/tests/avro/test_save_load.cpp
index 0bc4d3dc..a5ba510a 100644
--- a/tests/avro/test_save_load.cpp
+++ b/tests/avro/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/avro.hpp>
 #include <string>
diff --git a/tests/avro/test_set.cpp b/tests/avro/test_set.cpp
index cd5c778c..83a04493 100644
--- a/tests/avro/test_set.cpp
+++ b/tests/avro/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_shared_ptr.cpp b/tests/avro/test_shared_ptr.cpp
index 5e9fb6ba..9026e213 100644
--- a/tests/avro/test_shared_ptr.cpp
+++ b/tests/avro/test_shared_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/avro/test_size.cpp b/tests/avro/test_size.cpp
index 271ae64f..7ea30726 100644
--- a/tests/avro/test_size.cpp
+++ b/tests/avro/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/avro/test_snake_case_to_camel_case.cpp b/tests/avro/test_snake_case_to_camel_case.cpp
index 11e9e009..eea79fa3 100644
--- a/tests/avro/test_snake_case_to_camel_case.cpp
+++ b/tests/avro/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/avro/test_snake_case_to_pascal_case.cpp b/tests/avro/test_snake_case_to_pascal_case.cpp
index 1ddbe232..ea4b2270 100644
--- a/tests/avro/test_snake_case_to_pascal_case.cpp
+++ b/tests/avro/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/avro/test_string_map.cpp b/tests/avro/test_string_map.cpp
index 7f650532..4c4ed0c4 100644
--- a/tests/avro/test_string_map.cpp
+++ b/tests/avro/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/avro/test_tagged_union.cpp b/tests/avro/test_tagged_union.cpp
index 2ed9359f..7e6f40e9 100644
--- a/tests/avro/test_tagged_union.cpp
+++ b/tests/avro/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_timestamp.cpp b/tests/avro/test_timestamp.cpp
index 27086911..aa4d050b 100644
--- a/tests/avro/test_timestamp.cpp
+++ b/tests/avro/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_tutorial_example.cpp b/tests/avro/test_tutorial_example.cpp
index a198b319..3d430b25 100644
--- a/tests/avro/test_tutorial_example.cpp
+++ b/tests/avro/test_tutorial_example.cpp
@@ -1,12 +1,10 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/avro.hpp>
 #include <string>
-#include <vector>
 
-#include "write_and_read.hpp"
+//#include "write_and_read.hpp"
 
 /// The basic example from the Avro C tutorial.
 namespace test_tutorial_example {
diff --git a/tests/avro/test_tutorial_example_automated_schema.cpp b/tests/avro/test_tutorial_example_automated_schema.cpp
index 7d2af0f3..d67a9959 100644
--- a/tests/avro/test_tutorial_example_automated_schema.cpp
+++ b/tests/avro/test_tutorial_example_automated_schema.cpp
@@ -1,10 +1,8 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/avro.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_unique_ptr.cpp b/tests/avro/test_unique_ptr.cpp
index c2d50012..c48ad386 100644
--- a/tests/avro/test_unique_ptr.cpp
+++ b/tests/avro/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/avro/test_unique_ptr2.cpp b/tests/avro/test_unique_ptr2.cpp
index 9f663a72..b42255fa 100644
--- a/tests/avro/test_unique_ptr2.cpp
+++ b/tests/avro/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_variant.cpp b/tests/avro/test_variant.cpp
index 72d7ed34..80ad2819 100644
--- a/tests/avro/test_variant.cpp
+++ b/tests/avro/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/test_wstring.cpp b/tests/avro/test_wstring.cpp
index 4cdf0b5b..2810272e 100644
--- a/tests/avro/test_wstring.cpp
+++ b/tests/avro/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/avro/write_and_read.hpp b/tests/avro/write_and_read.hpp
index 71779de7..7a8f801b 100644
--- a/tests/avro/write_and_read.hpp
+++ b/tests/avro/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/avro.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/bson/test_add_struct_name.cpp b/tests/bson/test_add_struct_name.cpp
index 9405b2e4..f9d5800d 100644
--- a/tests/bson/test_add_struct_name.cpp
+++ b/tests/bson/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/bson/test_array.cpp b/tests/bson/test_array.cpp
index 4c9e8f14..5032090a 100644
--- a/tests/bson/test_array.cpp
+++ b/tests/bson/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/bson.hpp>
 #include <string>
diff --git a/tests/bson/test_box.cpp b/tests/bson/test_box.cpp
index 365be874..148ff54a 100644
--- a/tests/bson/test_box.cpp
+++ b/tests/bson/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_bytestring.cpp b/tests/bson/test_bytestring.cpp
index c7ca18cf..16d5bb7a 100644
--- a/tests/bson/test_bytestring.cpp
+++ b/tests/bson/test_bytestring.cpp
@@ -1,6 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/bson/test_combined_processors.cpp b/tests/bson/test_combined_processors.cpp
index fd9f55ff..477a3e78 100644
--- a/tests/bson/test_combined_processors.cpp
+++ b/tests/bson/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/bson/test_custom_class1.cpp b/tests/bson/test_custom_class1.cpp
index 95d51b21..a0d10333 100644
--- a/tests/bson/test_custom_class1.cpp
+++ b/tests/bson/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/bson/test_custom_class3.cpp b/tests/bson/test_custom_class3.cpp
index 17348482..66f36491 100644
--- a/tests/bson/test_custom_class3.cpp
+++ b/tests/bson/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_custom_class4.cpp b/tests/bson/test_custom_class4.cpp
index 3f4deb9e..725eeb1a 100644
--- a/tests/bson/test_custom_class4.cpp
+++ b/tests/bson/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_default_values.cpp b/tests/bson/test_default_values.cpp
index 67d20bce..9db8a2e6 100644
--- a/tests/bson/test_default_values.cpp
+++ b/tests/bson/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/bson/test_deque.cpp b/tests/bson/test_deque.cpp
index 6a1ac8c5..fd466196 100644
--- a/tests/bson/test_deque.cpp
+++ b/tests/bson/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_enum.cpp b/tests/bson/test_enum.cpp
index 2b99b125..624aa7e8 100644
--- a/tests/bson/test_enum.cpp
+++ b/tests/bson/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_field_variant.cpp b/tests/bson/test_field_variant.cpp
index ef55cfc4..3d506e92 100644
--- a/tests/bson/test_field_variant.cpp
+++ b/tests/bson/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_flag_enum.cpp b/tests/bson/test_flag_enum.cpp
index 1e534d34..37aaf968 100644
--- a/tests/bson/test_flag_enum.cpp
+++ b/tests/bson/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_flag_enum_with_int.cpp b/tests/bson/test_flag_enum_with_int.cpp
index ab04251f..3c1b3d77 100644
--- a/tests/bson/test_flag_enum_with_int.cpp
+++ b/tests/bson/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_flatten_anonymous.cpp b/tests/bson/test_flatten_anonymous.cpp
index d0a1fc3e..890651f0 100644
--- a/tests/bson/test_flatten_anonymous.cpp
+++ b/tests/bson/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_forward_list.cpp b/tests/bson/test_forward_list.cpp
index a8ed8370..0ccb0814 100644
--- a/tests/bson/test_forward_list.cpp
+++ b/tests/bson/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_literal.cpp b/tests/bson/test_literal.cpp
index bd608a1f..a8b4cd1c 100644
--- a/tests/bson/test_literal.cpp
+++ b/tests/bson/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/bson/test_literal_map.cpp b/tests/bson/test_literal_map.cpp
index 04c5f394..d4285cd5 100644
--- a/tests/bson/test_literal_map.cpp
+++ b/tests/bson/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_map.cpp b/tests/bson/test_map.cpp
index 14a16aaf..b40305e2 100644
--- a/tests/bson/test_map.cpp
+++ b/tests/bson/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/bson/test_map_with_key_validation.cpp b/tests/bson/test_map_with_key_validation.cpp
index 8bc3107e..82dca8c8 100644
--- a/tests/bson/test_map_with_key_validation.cpp
+++ b/tests/bson/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/bson/test_monster_example.cpp b/tests/bson/test_monster_example.cpp
index 2b2b7cd1..55aa804f 100644
--- a/tests/bson/test_monster_example.cpp
+++ b/tests/bson/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/bson/test_oid.cpp b/tests/bson/test_oid.cpp
index 335359ce..a20cb335 100644
--- a/tests/bson/test_oid.cpp
+++ b/tests/bson/test_oid.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_readme_example.cpp b/tests/bson/test_readme_example.cpp
index 83061da4..dd43cea1 100644
--- a/tests/bson/test_readme_example.cpp
+++ b/tests/bson/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/bson/test_readme_example2.cpp b/tests/bson/test_readme_example2.cpp
index 0ea6c2f1..ac13250c 100644
--- a/tests/bson/test_readme_example2.cpp
+++ b/tests/bson/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_ref.cpp b/tests/bson/test_ref.cpp
index 34ee53f7..6f6fc1bc 100644
--- a/tests/bson/test_ref.cpp
+++ b/tests/bson/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_save_load.cpp b/tests/bson/test_save_load.cpp
index 127f0a34..620d4969 100644
--- a/tests/bson/test_save_load.cpp
+++ b/tests/bson/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/bson.hpp>
 #include <string>
diff --git a/tests/bson/test_set.cpp b/tests/bson/test_set.cpp
index b1e0ce81..de3fc35d 100644
--- a/tests/bson/test_set.cpp
+++ b/tests/bson/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_size.cpp b/tests/bson/test_size.cpp
index 710dea9a..667a5a82 100644
--- a/tests/bson/test_size.cpp
+++ b/tests/bson/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/bson/test_snake_case_to_camel_case.cpp b/tests/bson/test_snake_case_to_camel_case.cpp
index e0eb3313..00210d77 100644
--- a/tests/bson/test_snake_case_to_camel_case.cpp
+++ b/tests/bson/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/bson/test_snake_case_to_pascal_case.cpp b/tests/bson/test_snake_case_to_pascal_case.cpp
index c709445c..f775e186 100644
--- a/tests/bson/test_snake_case_to_pascal_case.cpp
+++ b/tests/bson/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/bson/test_string_map.cpp b/tests/bson/test_string_map.cpp
index d6ccc090..715f332c 100644
--- a/tests/bson/test_string_map.cpp
+++ b/tests/bson/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/bson/test_tagged_union.cpp b/tests/bson/test_tagged_union.cpp
index 20e73efa..549d6f24 100644
--- a/tests/bson/test_tagged_union.cpp
+++ b/tests/bson/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_timestamp.cpp b/tests/bson/test_timestamp.cpp
index 038a4337..8ff8b7fb 100644
--- a/tests/bson/test_timestamp.cpp
+++ b/tests/bson/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_unique_ptr.cpp b/tests/bson/test_unique_ptr.cpp
index 70600754..0c829259 100644
--- a/tests/bson/test_unique_ptr.cpp
+++ b/tests/bson/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/bson/test_unique_ptr2.cpp b/tests/bson/test_unique_ptr2.cpp
index 4e7adb16..7baa452d 100644
--- a/tests/bson/test_unique_ptr2.cpp
+++ b/tests/bson/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_variant.cpp b/tests/bson/test_variant.cpp
index 02eb9bd0..d909356b 100644
--- a/tests/bson/test_variant.cpp
+++ b/tests/bson/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/test_vectorstring.cpp b/tests/bson/test_vectorstring.cpp
index 0cea16d1..db624c35 100644
--- a/tests/bson/test_vectorstring.cpp
+++ b/tests/bson/test_vectorstring.cpp
@@ -1,6 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/bson/test_wstring.cpp b/tests/bson/test_wstring.cpp
index faabbb07..70cabfe6 100644
--- a/tests/bson/test_wstring.cpp
+++ b/tests/bson/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/bson/write_and_read.hpp b/tests/bson/write_and_read.hpp
index 3a4242b3..5f38b081 100644
--- a/tests/bson/write_and_read.hpp
+++ b/tests/bson/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/bson.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/capnproto/test_add_struct_name.cpp b/tests/capnproto/test_add_struct_name.cpp
index 3fc04e97..64a93d33 100644
--- a/tests/capnproto/test_add_struct_name.cpp
+++ b/tests/capnproto/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/capnproto/test_array.cpp b/tests/capnproto/test_array.cpp
index bbaa618c..3753232c 100644
--- a/tests/capnproto/test_array.cpp
+++ b/tests/capnproto/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/capnproto.hpp>
 #include <string>
diff --git a/tests/capnproto/test_box.cpp b/tests/capnproto/test_box.cpp
index def342eb..33356d85 100644
--- a/tests/capnproto/test_box.cpp
+++ b/tests/capnproto/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_bytestring.cpp b/tests/capnproto/test_bytestring.cpp
index 43fa5c9b..fa531dc7 100644
--- a/tests/capnproto/test_bytestring.cpp
+++ b/tests/capnproto/test_bytestring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_custom_class1.cpp b/tests/capnproto/test_custom_class1.cpp
index e57e9d85..a8ca3dfe 100644
--- a/tests/capnproto/test_custom_class1.cpp
+++ b/tests/capnproto/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/capnproto/test_custom_class3.cpp b/tests/capnproto/test_custom_class3.cpp
index 0e90b9ba..9f47c9cb 100644
--- a/tests/capnproto/test_custom_class3.cpp
+++ b/tests/capnproto/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_custom_class4.cpp b/tests/capnproto/test_custom_class4.cpp
index 688d877c..867f6b46 100644
--- a/tests/capnproto/test_custom_class4.cpp
+++ b/tests/capnproto/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_default_values.cpp b/tests/capnproto/test_default_values.cpp
index 6d456271..756a89d4 100644
--- a/tests/capnproto/test_default_values.cpp
+++ b/tests/capnproto/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/capnproto/test_deque.cpp b/tests/capnproto/test_deque.cpp
index 250005fa..c26cf249 100644
--- a/tests/capnproto/test_deque.cpp
+++ b/tests/capnproto/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_enum.cpp b/tests/capnproto/test_enum.cpp
index fd92b6bc..c21e83af 100644
--- a/tests/capnproto/test_enum.cpp
+++ b/tests/capnproto/test_enum.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_field_variant.cpp b/tests/capnproto/test_field_variant.cpp
index 1418e9af..a6ca2789 100644
--- a/tests/capnproto/test_field_variant.cpp
+++ b/tests/capnproto/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_field_variant_std.cpp b/tests/capnproto/test_field_variant_std.cpp
index 2262fe2d..0aefd665 100644
--- a/tests/capnproto/test_field_variant_std.cpp
+++ b/tests/capnproto/test_field_variant_std.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_flag_enum.cpp b/tests/capnproto/test_flag_enum.cpp
index 17687653..fcb3981b 100644
--- a/tests/capnproto/test_flag_enum.cpp
+++ b/tests/capnproto/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_flag_enum_with_int.cpp b/tests/capnproto/test_flag_enum_with_int.cpp
index 08de18e2..dcc044ce 100644
--- a/tests/capnproto/test_flag_enum_with_int.cpp
+++ b/tests/capnproto/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_flatten.cpp b/tests/capnproto/test_flatten.cpp
index e461ac35..8392ac5b 100644
--- a/tests/capnproto/test_flatten.cpp
+++ b/tests/capnproto/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_flatten_anonymous.cpp b/tests/capnproto/test_flatten_anonymous.cpp
index 03749f15..92cf36d5 100644
--- a/tests/capnproto/test_flatten_anonymous.cpp
+++ b/tests/capnproto/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_forward_list.cpp b/tests/capnproto/test_forward_list.cpp
index 256c7437..a2910beb 100644
--- a/tests/capnproto/test_forward_list.cpp
+++ b/tests/capnproto/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_literal.cpp b/tests/capnproto/test_literal.cpp
index 441feec7..c1324c63 100644
--- a/tests/capnproto/test_literal.cpp
+++ b/tests/capnproto/test_literal.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/capnproto/test_literal_map.cpp b/tests/capnproto/test_literal_map.cpp
index e3149d5d..2e5a1cde 100644
--- a/tests/capnproto/test_literal_map.cpp
+++ b/tests/capnproto/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_map.cpp b/tests/capnproto/test_map.cpp
index a0e17f51..a43512d3 100644
--- a/tests/capnproto/test_map.cpp
+++ b/tests/capnproto/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/capnproto/test_map2.cpp b/tests/capnproto/test_map2.cpp
index ac2a5acc..82ad9bda 100644
--- a/tests/capnproto/test_map2.cpp
+++ b/tests/capnproto/test_map2.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/capnproto/test_monster_example.cpp b/tests/capnproto/test_monster_example.cpp
index d5a52e62..9d3e2cac 100644
--- a/tests/capnproto/test_monster_example.cpp
+++ b/tests/capnproto/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/capnproto/test_optional_fields.cpp b/tests/capnproto/test_optional_fields.cpp
index 6456fec4..05e6f3ea 100644
--- a/tests/capnproto/test_optional_fields.cpp
+++ b/tests/capnproto/test_optional_fields.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/capnproto/test_optionals_in_vectors.cpp b/tests/capnproto/test_optionals_in_vectors.cpp
index 10e49302..cfac09ec 100644
--- a/tests/capnproto/test_optionals_in_vectors.cpp
+++ b/tests/capnproto/test_optionals_in_vectors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/capnproto/test_person.cpp b/tests/capnproto/test_person.cpp
index 1e469935..dddb4880 100644
--- a/tests/capnproto/test_person.cpp
+++ b/tests/capnproto/test_person.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/capnproto.hpp>
 #include <string>
diff --git a/tests/capnproto/test_readme_example.cpp b/tests/capnproto/test_readme_example.cpp
index 3e911aa6..6e09fd78 100644
--- a/tests/capnproto/test_readme_example.cpp
+++ b/tests/capnproto/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/capnproto/test_readme_example2.cpp b/tests/capnproto/test_readme_example2.cpp
index 2f6f9b44..ea1087df 100644
--- a/tests/capnproto/test_readme_example2.cpp
+++ b/tests/capnproto/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_readme_example3.cpp b/tests/capnproto/test_readme_example3.cpp
index 1e898c40..dd89ff1e 100644
--- a/tests/capnproto/test_readme_example3.cpp
+++ b/tests/capnproto/test_readme_example3.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/capnproto/test_ref.cpp b/tests/capnproto/test_ref.cpp
index c9408b53..4c4a000b 100644
--- a/tests/capnproto/test_ref.cpp
+++ b/tests/capnproto/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_rfl_tuple.cpp b/tests/capnproto/test_rfl_tuple.cpp
index bcb7a162..6e94f36e 100644
--- a/tests/capnproto/test_rfl_tuple.cpp
+++ b/tests/capnproto/test_rfl_tuple.cpp
@@ -3,7 +3,6 @@
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <tuple>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_rfl_variant.cpp b/tests/capnproto/test_rfl_variant.cpp
index 45da5b74..81d715f4 100644
--- a/tests/capnproto/test_rfl_variant.cpp
+++ b/tests/capnproto/test_rfl_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_save_load.cpp b/tests/capnproto/test_save_load.cpp
index a64a1527..b782517a 100644
--- a/tests/capnproto/test_save_load.cpp
+++ b/tests/capnproto/test_save_load.cpp
@@ -1,7 +1,6 @@
 #include <gtest/gtest.h>
 
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/capnproto.hpp>
 #include <string>
diff --git a/tests/capnproto/test_set.cpp b/tests/capnproto/test_set.cpp
index d2f2732d..0881e460 100644
--- a/tests/capnproto/test_set.cpp
+++ b/tests/capnproto/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_shared_ptr.cpp b/tests/capnproto/test_shared_ptr.cpp
index 62857583..5639ce5a 100644
--- a/tests/capnproto/test_shared_ptr.cpp
+++ b/tests/capnproto/test_shared_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/capnproto/test_size.cpp b/tests/capnproto/test_size.cpp
index e85870e4..53cda167 100644
--- a/tests/capnproto/test_size.cpp
+++ b/tests/capnproto/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/capnproto/test_string_map.cpp b/tests/capnproto/test_string_map.cpp
index e1580d59..6da2173c 100644
--- a/tests/capnproto/test_string_map.cpp
+++ b/tests/capnproto/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/capnproto/test_tagged_union.cpp b/tests/capnproto/test_tagged_union.cpp
index 112cb448..4aa218e9 100644
--- a/tests/capnproto/test_tagged_union.cpp
+++ b/tests/capnproto/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_timestamp.cpp b/tests/capnproto/test_timestamp.cpp
index 1ea5b48a..119ec6f4 100644
--- a/tests/capnproto/test_timestamp.cpp
+++ b/tests/capnproto/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_tutorial_example.cpp b/tests/capnproto/test_tutorial_example.cpp
index 5271148f..338dc078 100644
--- a/tests/capnproto/test_tutorial_example.cpp
+++ b/tests/capnproto/test_tutorial_example.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/capnproto.hpp>
 #include <string>
diff --git a/tests/capnproto/test_unique_ptr.cpp b/tests/capnproto/test_unique_ptr.cpp
index ca5964b8..faee7144 100644
--- a/tests/capnproto/test_unique_ptr.cpp
+++ b/tests/capnproto/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/capnproto/test_unique_ptr2.cpp b/tests/capnproto/test_unique_ptr2.cpp
index b3459221..2387c582 100644
--- a/tests/capnproto/test_unique_ptr2.cpp
+++ b/tests/capnproto/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_variant.cpp b/tests/capnproto/test_variant.cpp
index 1f68ee2c..271b852a 100644
--- a/tests/capnproto/test_variant.cpp
+++ b/tests/capnproto/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/test_variants_in_vectors.cpp b/tests/capnproto/test_variants_in_vectors.cpp
index 8e9633fe..62128cae 100644
--- a/tests/capnproto/test_variants_in_vectors.cpp
+++ b/tests/capnproto/test_variants_in_vectors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/capnproto/test_wstring.cpp b/tests/capnproto/test_wstring.cpp
index a71e1571..39f4a38b 100644
--- a/tests/capnproto/test_wstring.cpp
+++ b/tests/capnproto/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/capnproto/write_and_read.hpp b/tests/capnproto/write_and_read.hpp
index 1e9d7b59..fab5c65e 100644
--- a/tests/capnproto/write_and_read.hpp
+++ b/tests/capnproto/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/capnproto.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/cbor/test_add_struct_name.cpp b/tests/cbor/test_add_struct_name.cpp
index bea8cc65..2d88a7e6 100644
--- a/tests/cbor/test_add_struct_name.cpp
+++ b/tests/cbor/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/cbor/test_array.cpp b/tests/cbor/test_array.cpp
index bb88db7c..e27b0e75 100644
--- a/tests/cbor/test_array.cpp
+++ b/tests/cbor/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/cbor.hpp>
 #include <string>
diff --git a/tests/cbor/test_box.cpp b/tests/cbor/test_box.cpp
index 4a5983ad..64e7ff16 100644
--- a/tests/cbor/test_box.cpp
+++ b/tests/cbor/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_bytestring.cpp b/tests/cbor/test_bytestring.cpp
index e433cc69..d5f5990b 100644
--- a/tests/cbor/test_bytestring.cpp
+++ b/tests/cbor/test_bytestring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_combined_processors.cpp b/tests/cbor/test_combined_processors.cpp
index b25cc913..eb166cbb 100644
--- a/tests/cbor/test_combined_processors.cpp
+++ b/tests/cbor/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/cbor/test_custom_class1.cpp b/tests/cbor/test_custom_class1.cpp
index a0aaafd7..dcf09b2a 100644
--- a/tests/cbor/test_custom_class1.cpp
+++ b/tests/cbor/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/cbor/test_custom_class3.cpp b/tests/cbor/test_custom_class3.cpp
index 2e690e94..c4370cfb 100644
--- a/tests/cbor/test_custom_class3.cpp
+++ b/tests/cbor/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_custom_class4.cpp b/tests/cbor/test_custom_class4.cpp
index 3da3831c..8539c79a 100644
--- a/tests/cbor/test_custom_class4.cpp
+++ b/tests/cbor/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_default_values.cpp b/tests/cbor/test_default_values.cpp
index 1e3c3b4a..82b16f66 100644
--- a/tests/cbor/test_default_values.cpp
+++ b/tests/cbor/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/cbor/test_deque.cpp b/tests/cbor/test_deque.cpp
index d3314f47..e9948149 100644
--- a/tests/cbor/test_deque.cpp
+++ b/tests/cbor/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_enum.cpp b/tests/cbor/test_enum.cpp
index 21bc19f9..861bd8b0 100644
--- a/tests/cbor/test_enum.cpp
+++ b/tests/cbor/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_error_messages.cpp b/tests/cbor/test_error_messages.cpp
index a38cbcb2..b8155fcb 100644
--- a/tests/cbor/test_error_messages.cpp
+++ b/tests/cbor/test_error_messages.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/cbor.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/cbor/test_extra_fields.cpp b/tests/cbor/test_extra_fields.cpp
index 8e7f7d87..fe77536e 100644
--- a/tests/cbor/test_extra_fields.cpp
+++ b/tests/cbor/test_extra_fields.cpp
@@ -1,8 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_field_variant.cpp b/tests/cbor/test_field_variant.cpp
index 87483aca..e8593657 100644
--- a/tests/cbor/test_field_variant.cpp
+++ b/tests/cbor/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_flag_enum.cpp b/tests/cbor/test_flag_enum.cpp
index 9feb82e4..f31a4e2e 100644
--- a/tests/cbor/test_flag_enum.cpp
+++ b/tests/cbor/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_flag_enum_with_int.cpp b/tests/cbor/test_flag_enum_with_int.cpp
index efd2d764..8978d096 100644
--- a/tests/cbor/test_flag_enum_with_int.cpp
+++ b/tests/cbor/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_flatten.cpp b/tests/cbor/test_flatten.cpp
index 9a47818c..37891514 100644
--- a/tests/cbor/test_flatten.cpp
+++ b/tests/cbor/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_flatten_anonymous.cpp b/tests/cbor/test_flatten_anonymous.cpp
index 1ebc81ff..e9a71966 100644
--- a/tests/cbor/test_flatten_anonymous.cpp
+++ b/tests/cbor/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_forward_list.cpp b/tests/cbor/test_forward_list.cpp
index d6ec0f4a..cb5f89e2 100644
--- a/tests/cbor/test_forward_list.cpp
+++ b/tests/cbor/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_literal.cpp b/tests/cbor/test_literal.cpp
index d80cd2b0..591e6081 100644
--- a/tests/cbor/test_literal.cpp
+++ b/tests/cbor/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/cbor/test_literal_map.cpp b/tests/cbor/test_literal_map.cpp
index da0b31b2..ab101abf 100644
--- a/tests/cbor/test_literal_map.cpp
+++ b/tests/cbor/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_map.cpp b/tests/cbor/test_map.cpp
index f2336d4b..25d45e0f 100644
--- a/tests/cbor/test_map.cpp
+++ b/tests/cbor/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/cbor/test_map_with_key_validation.cpp b/tests/cbor/test_map_with_key_validation.cpp
index aac3f05d..d7bb1c13 100644
--- a/tests/cbor/test_map_with_key_validation.cpp
+++ b/tests/cbor/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/cbor/test_monster_example.cpp b/tests/cbor/test_monster_example.cpp
index 76f5abb5..1569def7 100644
--- a/tests/cbor/test_monster_example.cpp
+++ b/tests/cbor/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/cbor/test_optional_fields.cpp b/tests/cbor/test_optional_fields.cpp
index e26bf309..6a430903 100644
--- a/tests/cbor/test_optional_fields.cpp
+++ b/tests/cbor/test_optional_fields.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/cbor.hpp>
 #include <string>
diff --git a/tests/cbor/test_readme_example.cpp b/tests/cbor/test_readme_example.cpp
index 6654f28c..c069be9c 100644
--- a/tests/cbor/test_readme_example.cpp
+++ b/tests/cbor/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/cbor/test_readme_example2.cpp b/tests/cbor/test_readme_example2.cpp
index 53562ec2..54ec6de6 100644
--- a/tests/cbor/test_readme_example2.cpp
+++ b/tests/cbor/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_ref.cpp b/tests/cbor/test_ref.cpp
index a0def5f9..60d434b5 100644
--- a/tests/cbor/test_ref.cpp
+++ b/tests/cbor/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_save_load.cpp b/tests/cbor/test_save_load.cpp
index fd00bdd8..54f3f2b5 100644
--- a/tests/cbor/test_save_load.cpp
+++ b/tests/cbor/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/cbor.hpp>
 #include <string>
diff --git a/tests/cbor/test_set.cpp b/tests/cbor/test_set.cpp
index d012082e..148a0d43 100644
--- a/tests/cbor/test_set.cpp
+++ b/tests/cbor/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_size.cpp b/tests/cbor/test_size.cpp
index 4adf30fb..33b79a21 100644
--- a/tests/cbor/test_size.cpp
+++ b/tests/cbor/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/cbor/test_snake_case_to_camel_case.cpp b/tests/cbor/test_snake_case_to_camel_case.cpp
index 1b0ecc08..b901b8b2 100644
--- a/tests/cbor/test_snake_case_to_camel_case.cpp
+++ b/tests/cbor/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/cbor/test_snake_case_to_pascal_case.cpp b/tests/cbor/test_snake_case_to_pascal_case.cpp
index 71db07d6..1f072e0c 100644
--- a/tests/cbor/test_snake_case_to_pascal_case.cpp
+++ b/tests/cbor/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/cbor/test_string_map.cpp b/tests/cbor/test_string_map.cpp
index 839178f9..c86a4280 100644
--- a/tests/cbor/test_string_map.cpp
+++ b/tests/cbor/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/cbor/test_tagged_union.cpp b/tests/cbor/test_tagged_union.cpp
index 0f14bc03..b4bc688f 100644
--- a/tests/cbor/test_tagged_union.cpp
+++ b/tests/cbor/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_tagged_union2.cpp b/tests/cbor/test_tagged_union2.cpp
index 2e5495a3..e8c13cec 100644
--- a/tests/cbor/test_tagged_union2.cpp
+++ b/tests/cbor/test_tagged_union2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_timestamp.cpp b/tests/cbor/test_timestamp.cpp
index 1352a88a..295a28c2 100644
--- a/tests/cbor/test_timestamp.cpp
+++ b/tests/cbor/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_unique_ptr.cpp b/tests/cbor/test_unique_ptr.cpp
index bbb4709c..49129d99 100644
--- a/tests/cbor/test_unique_ptr.cpp
+++ b/tests/cbor/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/cbor/test_unique_ptr2.cpp b/tests/cbor/test_unique_ptr2.cpp
index 0ce97fb4..41f2ed91 100644
--- a/tests/cbor/test_unique_ptr2.cpp
+++ b/tests/cbor/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_variant.cpp b/tests/cbor/test_variant.cpp
index 78a37761..7ba1c02b 100644
--- a/tests/cbor/test_variant.cpp
+++ b/tests/cbor/test_variant.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_variant_auto_tagging.cpp b/tests/cbor/test_variant_auto_tagging.cpp
index 0f7b79e2..c8ab2e0d 100644
--- a/tests/cbor/test_variant_auto_tagging.cpp
+++ b/tests/cbor/test_variant_auto_tagging.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/cbor/test_vectorstring.cpp b/tests/cbor/test_vectorstring.cpp
index dc424614..682290d1 100644
--- a/tests/cbor/test_vectorstring.cpp
+++ b/tests/cbor/test_vectorstring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/cbor/test_wstring.cpp b/tests/cbor/test_wstring.cpp
index 599588c1..9c4c11b7 100644
--- a/tests/cbor/test_wstring.cpp
+++ b/tests/cbor/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/csv/test_boolean.cpp b/tests/csv/test_boolean.cpp
index 6d9b01c1..39ad77c1 100644
--- a/tests/csv/test_boolean.cpp
+++ b/tests/csv/test_boolean.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_box.cpp b/tests/csv/test_box.cpp
index 1470b416..507a707a 100644
--- a/tests/csv/test_box.cpp
+++ b/tests/csv/test_box.cpp
@@ -1,5 +1,3 @@
-#include <iostream>
-#include <memory>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_bytestring.cpp b/tests/csv/test_bytestring.cpp
index abd7d09c..465d135d 100644
--- a/tests/csv/test_bytestring.cpp
+++ b/tests/csv/test_bytestring.cpp
@@ -1,6 +1,4 @@
-#include <iostream>
 #include <rfl/csv.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/csv/test_camel_case.cpp b/tests/csv/test_camel_case.cpp
index 6d72baaf..fe1de933 100644
--- a/tests/csv/test_camel_case.cpp
+++ b/tests/csv/test_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_deque.cpp b/tests/csv/test_deque.cpp
index d863ae69..fb02306d 100644
--- a/tests/csv/test_deque.cpp
+++ b/tests/csv/test_deque.cpp
@@ -1,5 +1,4 @@
 #include <deque>
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 
diff --git a/tests/csv/test_enums.cpp b/tests/csv/test_enums.cpp
index 17af9078..cb7897df 100644
--- a/tests/csv/test_enums.cpp
+++ b/tests/csv/test_enums.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_flatten.cpp b/tests/csv/test_flatten.cpp
index 2e0ff859..a5dca536 100644
--- a/tests/csv/test_flatten.cpp
+++ b/tests/csv/test_flatten.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_literal.cpp b/tests/csv/test_literal.cpp
index a5f74397..3c3f1694 100644
--- a/tests/csv/test_literal.cpp
+++ b/tests/csv/test_literal.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_optionals.cpp b/tests/csv/test_optionals.cpp
index 3c99df9f..fac02974 100644
--- a/tests/csv/test_optionals.cpp
+++ b/tests/csv/test_optionals.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <optional>
 #include <rfl/csv.hpp>
 #include <string>
diff --git a/tests/csv/test_readme_example.cpp b/tests/csv/test_readme_example.cpp
index 9bd29186..3d39b54f 100644
--- a/tests/csv/test_readme_example.cpp
+++ b/tests/csv/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_ref.cpp b/tests/csv/test_ref.cpp
index 2bf21901..b48f36ac 100644
--- a/tests/csv/test_ref.cpp
+++ b/tests/csv/test_ref.cpp
@@ -1,5 +1,3 @@
-#include <iostream>
-#include <memory>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_save_load.cpp b/tests/csv/test_save_load.cpp
index 5f1cd69b..14ef4ff2 100644
--- a/tests/csv/test_save_load.cpp
+++ b/tests/csv/test_save_load.cpp
@@ -1,7 +1,6 @@
 #include <gtest/gtest.h>
 
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/csv.hpp>
 #include <string>
diff --git a/tests/csv/test_settings.cpp b/tests/csv/test_settings.cpp
index cc228cde..ca3ddbb1 100644
--- a/tests/csv/test_settings.cpp
+++ b/tests/csv/test_settings.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/csv.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/csv/test_shared_ptr.cpp b/tests/csv/test_shared_ptr.cpp
index 72cab308..88b7ec71 100644
--- a/tests/csv/test_shared_ptr.cpp
+++ b/tests/csv/test_shared_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl/csv.hpp>
 #include <string>
diff --git a/tests/csv/test_unique_ptr.cpp b/tests/csv/test_unique_ptr.cpp
index b41cb1fa..a0448f0c 100644
--- a/tests/csv/test_unique_ptr.cpp
+++ b/tests/csv/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl/csv.hpp>
 #include <string>
diff --git a/tests/csv/write_and_read.hpp b/tests/csv/write_and_read.hpp
index 4640e962..d5198e4e 100644
--- a/tests/csv/write_and_read.hpp
+++ b/tests/csv/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/csv.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _vec, const rfl::csv::Settings& _settings =
diff --git a/tests/flexbuffers/test_add_struct_name.cpp b/tests/flexbuffers/test_add_struct_name.cpp
index 798903e8..7b63625a 100644
--- a/tests/flexbuffers/test_add_struct_name.cpp
+++ b/tests/flexbuffers/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/flexbuffers/test_array.cpp b/tests/flexbuffers/test_array.cpp
index ad39e093..76ec1eb4 100644
--- a/tests/flexbuffers/test_array.cpp
+++ b/tests/flexbuffers/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/flexbuf.hpp>
 #include <string>
diff --git a/tests/flexbuffers/test_box.cpp b/tests/flexbuffers/test_box.cpp
index df099523..fdfd8994 100644
--- a/tests/flexbuffers/test_box.cpp
+++ b/tests/flexbuffers/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_bytestring.cpp b/tests/flexbuffers/test_bytestring.cpp
index 5220ee7b..abbf3d4e 100644
--- a/tests/flexbuffers/test_bytestring.cpp
+++ b/tests/flexbuffers/test_bytestring.cpp
@@ -1,6 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/flexbuffers/test_combined_processors.cpp b/tests/flexbuffers/test_combined_processors.cpp
index e9e69ee6..1a0011bc 100644
--- a/tests/flexbuffers/test_combined_processors.cpp
+++ b/tests/flexbuffers/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/flexbuffers/test_custom_class1.cpp b/tests/flexbuffers/test_custom_class1.cpp
index 3de0735b..bfc65a70 100644
--- a/tests/flexbuffers/test_custom_class1.cpp
+++ b/tests/flexbuffers/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/flexbuffers/test_custom_class3.cpp b/tests/flexbuffers/test_custom_class3.cpp
index 1be44e68..26a72132 100644
--- a/tests/flexbuffers/test_custom_class3.cpp
+++ b/tests/flexbuffers/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_custom_class4.cpp b/tests/flexbuffers/test_custom_class4.cpp
index da5de307..3d1495f6 100644
--- a/tests/flexbuffers/test_custom_class4.cpp
+++ b/tests/flexbuffers/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_default_values.cpp b/tests/flexbuffers/test_default_values.cpp
index 36d14d31..a8d6460c 100644
--- a/tests/flexbuffers/test_default_values.cpp
+++ b/tests/flexbuffers/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/flexbuffers/test_enum.cpp b/tests/flexbuffers/test_enum.cpp
index d9cd1e1c..3f751a47 100644
--- a/tests/flexbuffers/test_enum.cpp
+++ b/tests/flexbuffers/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_field_variant.cpp b/tests/flexbuffers/test_field_variant.cpp
index 0299c63a..3c3106fd 100644
--- a/tests/flexbuffers/test_field_variant.cpp
+++ b/tests/flexbuffers/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_flag_enum.cpp b/tests/flexbuffers/test_flag_enum.cpp
index 10ae810c..9792444b 100644
--- a/tests/flexbuffers/test_flag_enum.cpp
+++ b/tests/flexbuffers/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_flag_enum_with_int.cpp b/tests/flexbuffers/test_flag_enum_with_int.cpp
index 22ca1814..740c6135 100644
--- a/tests/flexbuffers/test_flag_enum_with_int.cpp
+++ b/tests/flexbuffers/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_flatten_anonymous.cpp b/tests/flexbuffers/test_flatten_anonymous.cpp
index a381dc80..6a7e5eab 100644
--- a/tests/flexbuffers/test_flatten_anonymous.cpp
+++ b/tests/flexbuffers/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_forward_list.cpp b/tests/flexbuffers/test_forward_list.cpp
index 638667bd..79c1e01b 100644
--- a/tests/flexbuffers/test_forward_list.cpp
+++ b/tests/flexbuffers/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_literal.cpp b/tests/flexbuffers/test_literal.cpp
index cafced86..5cf835e5 100644
--- a/tests/flexbuffers/test_literal.cpp
+++ b/tests/flexbuffers/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/flexbuffers/test_literal_map.cpp b/tests/flexbuffers/test_literal_map.cpp
index fe739f9e..48fcbec4 100644
--- a/tests/flexbuffers/test_literal_map.cpp
+++ b/tests/flexbuffers/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_map.cpp b/tests/flexbuffers/test_map.cpp
index d3705b20..95e9a7a0 100644
--- a/tests/flexbuffers/test_map.cpp
+++ b/tests/flexbuffers/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/flexbuffers/test_map_with_key_validation.cpp b/tests/flexbuffers/test_map_with_key_validation.cpp
index 1ea67638..eccf0485 100644
--- a/tests/flexbuffers/test_map_with_key_validation.cpp
+++ b/tests/flexbuffers/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/flexbuffers/test_monster_example.cpp b/tests/flexbuffers/test_monster_example.cpp
index 66ef05f2..3c52c99f 100644
--- a/tests/flexbuffers/test_monster_example.cpp
+++ b/tests/flexbuffers/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/flexbuffers/test_readme_example2.cpp b/tests/flexbuffers/test_readme_example2.cpp
index aaae45b8..d8f37efc 100644
--- a/tests/flexbuffers/test_readme_example2.cpp
+++ b/tests/flexbuffers/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_ref.cpp b/tests/flexbuffers/test_ref.cpp
index 4ad6aa05..c02ccf90 100644
--- a/tests/flexbuffers/test_ref.cpp
+++ b/tests/flexbuffers/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_save_load.cpp b/tests/flexbuffers/test_save_load.cpp
index bc9e0950..0754c7d4 100644
--- a/tests/flexbuffers/test_save_load.cpp
+++ b/tests/flexbuffers/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/flexbuf.hpp>
 #include <string>
diff --git a/tests/flexbuffers/test_snake_case_to_camel_case.cpp b/tests/flexbuffers/test_snake_case_to_camel_case.cpp
index b23ba6f7..35c85ab6 100644
--- a/tests/flexbuffers/test_snake_case_to_camel_case.cpp
+++ b/tests/flexbuffers/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/flexbuffers/test_snake_case_to_pascal_case.cpp b/tests/flexbuffers/test_snake_case_to_pascal_case.cpp
index 64736494..b53414b1 100644
--- a/tests/flexbuffers/test_snake_case_to_pascal_case.cpp
+++ b/tests/flexbuffers/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/flexbuffers/test_string_map.cpp b/tests/flexbuffers/test_string_map.cpp
index ba9b0647..384e37bf 100644
--- a/tests/flexbuffers/test_string_map.cpp
+++ b/tests/flexbuffers/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/flexbuffers/test_tagged_union.cpp b/tests/flexbuffers/test_tagged_union.cpp
index d58db557..bb717300 100644
--- a/tests/flexbuffers/test_tagged_union.cpp
+++ b/tests/flexbuffers/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_tagged_union2.cpp b/tests/flexbuffers/test_tagged_union2.cpp
index d322ef42..050b4f4f 100644
--- a/tests/flexbuffers/test_tagged_union2.cpp
+++ b/tests/flexbuffers/test_tagged_union2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_timestamp.cpp b/tests/flexbuffers/test_timestamp.cpp
index a1b6c80c..1317b58b 100644
--- a/tests/flexbuffers/test_timestamp.cpp
+++ b/tests/flexbuffers/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_unique_ptr.cpp b/tests/flexbuffers/test_unique_ptr.cpp
index 972b9fd7..979b6cd5 100644
--- a/tests/flexbuffers/test_unique_ptr.cpp
+++ b/tests/flexbuffers/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/flexbuffers/test_unique_ptr2.cpp b/tests/flexbuffers/test_unique_ptr2.cpp
index 03c2e304..a0a03f98 100644
--- a/tests/flexbuffers/test_unique_ptr2.cpp
+++ b/tests/flexbuffers/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_variant.cpp b/tests/flexbuffers/test_variant.cpp
index 2e66cf66..933fcbed 100644
--- a/tests/flexbuffers/test_variant.cpp
+++ b/tests/flexbuffers/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/test_wstring.cpp b/tests/flexbuffers/test_wstring.cpp
index 8b42945f..b0ab7f1f 100644
--- a/tests/flexbuffers/test_wstring.cpp
+++ b/tests/flexbuffers/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/flexbuffers/write_and_read.hpp b/tests/flexbuffers/write_and_read.hpp
index 1a10fc30..0eeef2d6 100644
--- a/tests/flexbuffers/write_and_read.hpp
+++ b/tests/flexbuffers/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/flexbuf.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/generic/test_add_struct_name.cpp b/tests/generic/test_add_struct_name.cpp
index c077e7ab..9e76cda7 100644
--- a/tests/generic/test_add_struct_name.cpp
+++ b/tests/generic/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/generic/test_array.cpp b/tests/generic/test_array.cpp
index 42da200e..e1ddba69 100644
--- a/tests/generic/test_array.cpp
+++ b/tests/generic/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/generic/test_box.cpp b/tests/generic/test_box.cpp
index bfa1eb8d..e91fae93 100644
--- a/tests/generic/test_box.cpp
+++ b/tests/generic/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_combined_processors.cpp b/tests/generic/test_combined_processors.cpp
index 640ff064..2ffe629b 100644
--- a/tests/generic/test_combined_processors.cpp
+++ b/tests/generic/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/generic/test_custom_class1.cpp b/tests/generic/test_custom_class1.cpp
index 5691923e..3fed8cd9 100644
--- a/tests/generic/test_custom_class1.cpp
+++ b/tests/generic/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/generic/test_custom_class3.cpp b/tests/generic/test_custom_class3.cpp
index 278ecba3..b89b2f2b 100644
--- a/tests/generic/test_custom_class3.cpp
+++ b/tests/generic/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_custom_class4.cpp b/tests/generic/test_custom_class4.cpp
index bf97dbac..093de954 100644
--- a/tests/generic/test_custom_class4.cpp
+++ b/tests/generic/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_default_values.cpp b/tests/generic/test_default_values.cpp
index 5ceee9ee..e378102a 100644
--- a/tests/generic/test_default_values.cpp
+++ b/tests/generic/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/generic/test_deque.cpp b/tests/generic/test_deque.cpp
index f272b19c..568e20d7 100644
--- a/tests/generic/test_deque.cpp
+++ b/tests/generic/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_enum.cpp b/tests/generic/test_enum.cpp
index c183fe70..cec7f965 100644
--- a/tests/generic/test_enum.cpp
+++ b/tests/generic/test_enum.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_enum_range.cpp b/tests/generic/test_enum_range.cpp
index 32e33403..4b54a671 100644
--- a/tests/generic/test_enum_range.cpp
+++ b/tests/generic/test_enum_range.cpp
@@ -3,7 +3,6 @@
 #define RFL_ENUM_RANGE_MIN -128
 #define RFL_ENUM_RANGE_MAX 128
 #include <rfl.hpp>
-#include <string>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_field_variant.cpp b/tests/generic/test_field_variant.cpp
index 5855c369..452a79df 100644
--- a/tests/generic/test_field_variant.cpp
+++ b/tests/generic/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_flag_enum.cpp b/tests/generic/test_flag_enum.cpp
index 9b914db2..5285a4bf 100644
--- a/tests/generic/test_flag_enum.cpp
+++ b/tests/generic/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_flag_enum_with_int.cpp b/tests/generic/test_flag_enum_with_int.cpp
index ec77a1a6..717a7c0a 100644
--- a/tests/generic/test_flag_enum_with_int.cpp
+++ b/tests/generic/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_flatten.cpp b/tests/generic/test_flatten.cpp
index caecb3f7..07f8cb19 100644
--- a/tests/generic/test_flatten.cpp
+++ b/tests/generic/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_flatten_anonymous.cpp b/tests/generic/test_flatten_anonymous.cpp
index 908e381b..757af931 100644
--- a/tests/generic/test_flatten_anonymous.cpp
+++ b/tests/generic/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_forward_list.cpp b/tests/generic/test_forward_list.cpp
index 0dc273d2..e8096ca3 100644
--- a/tests/generic/test_forward_list.cpp
+++ b/tests/generic/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_literal.cpp b/tests/generic/test_literal.cpp
index 07c2f340..9c702a41 100644
--- a/tests/generic/test_literal.cpp
+++ b/tests/generic/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/generic/test_literal_map.cpp b/tests/generic/test_literal_map.cpp
index 29398f66..391bcde9 100644
--- a/tests/generic/test_literal_map.cpp
+++ b/tests/generic/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_map.cpp b/tests/generic/test_map.cpp
index 2d93c09c..ed334d46 100644
--- a/tests/generic/test_map.cpp
+++ b/tests/generic/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/generic/test_map_with_key_validation.cpp b/tests/generic/test_map_with_key_validation.cpp
index 51ea916b..ec81884f 100644
--- a/tests/generic/test_map_with_key_validation.cpp
+++ b/tests/generic/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/generic/test_monster_example.cpp b/tests/generic/test_monster_example.cpp
index e2b78d7b..afcfd9ac 100644
--- a/tests/generic/test_monster_example.cpp
+++ b/tests/generic/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/generic/test_readme_example.cpp b/tests/generic/test_readme_example.cpp
index ae633bff..0a9ffafd 100644
--- a/tests/generic/test_readme_example.cpp
+++ b/tests/generic/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/generic/test_readme_example2.cpp b/tests/generic/test_readme_example2.cpp
index 9c07de1b..4808ad17 100644
--- a/tests/generic/test_readme_example2.cpp
+++ b/tests/generic/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_ref.cpp b/tests/generic/test_ref.cpp
index 135e4a3b..8acf2441 100644
--- a/tests/generic/test_ref.cpp
+++ b/tests/generic/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_set.cpp b/tests/generic/test_set.cpp
index 23b1db3e..985d7fc5 100644
--- a/tests/generic/test_set.cpp
+++ b/tests/generic/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_size.cpp b/tests/generic/test_size.cpp
index 4725afa4..daf75dbb 100644
--- a/tests/generic/test_size.cpp
+++ b/tests/generic/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/generic/test_snake_case_to_camel_case.cpp b/tests/generic/test_snake_case_to_camel_case.cpp
index 3c4df29d..0edbc478 100644
--- a/tests/generic/test_snake_case_to_camel_case.cpp
+++ b/tests/generic/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/generic/test_snake_case_to_pascal_case.cpp b/tests/generic/test_snake_case_to_pascal_case.cpp
index dfa17ea3..4f9f8840 100644
--- a/tests/generic/test_snake_case_to_pascal_case.cpp
+++ b/tests/generic/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/generic/test_string_map.cpp b/tests/generic/test_string_map.cpp
index 13cd03cb..688453c5 100644
--- a/tests/generic/test_string_map.cpp
+++ b/tests/generic/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/generic/test_tagged_union.cpp b/tests/generic/test_tagged_union.cpp
index 2b677109..8a4901a8 100644
--- a/tests/generic/test_tagged_union.cpp
+++ b/tests/generic/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_timestamp.cpp b/tests/generic/test_timestamp.cpp
index e6b86bdc..d658b30b 100644
--- a/tests/generic/test_timestamp.cpp
+++ b/tests/generic/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_unique_ptr.cpp b/tests/generic/test_unique_ptr.cpp
index 38748000..2b32e7a1 100644
--- a/tests/generic/test_unique_ptr.cpp
+++ b/tests/generic/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/generic/test_unique_ptr2.cpp b/tests/generic/test_unique_ptr2.cpp
index 6ec7eaa2..ee51e202 100644
--- a/tests/generic/test_unique_ptr2.cpp
+++ b/tests/generic/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_variant.cpp b/tests/generic/test_variant.cpp
index 3767b020..5bbf6abf 100644
--- a/tests/generic/test_variant.cpp
+++ b/tests/generic/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/test_wstring.cpp b/tests/generic/test_wstring.cpp
index a11ca8fa..275c3d5a 100644
--- a/tests/generic/test_wstring.cpp
+++ b/tests/generic/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/generic/write_and_read.hpp b/tests/generic/write_and_read.hpp
index 66cc17c7..abf3aabd 100644
--- a/tests/generic/write_and_read.hpp
+++ b/tests/generic/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/json.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/json/test_apply_on_named_tuple.cpp b/tests/json/test_apply_on_named_tuple.cpp
index 686e879f..d9e02f1b 100644
--- a/tests/json/test_apply_on_named_tuple.cpp
+++ b/tests/json/test_apply_on_named_tuple.cpp
@@ -3,8 +3,6 @@
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <type_traits>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_binary.cpp b/tests/json/test_binary.cpp
index 9cabed7e..c6dc4a3e 100644
--- a/tests/json/test_binary.cpp
+++ b/tests/json/test_binary.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_combined_processors.cpp b/tests/json/test_combined_processors.cpp
index 464499c2..ef69df41 100644
--- a/tests/json/test_combined_processors.cpp
+++ b/tests/json/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_const_fields.cpp b/tests/json/test_const_fields.cpp
index c3bcbd26..d9898069 100644
--- a/tests/json/test_const_fields.cpp
+++ b/tests/json/test_const_fields.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <optional>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_custom_class1.cpp b/tests/json/test_custom_class1.cpp
index ce7a549b..6df48316 100644
--- a/tests/json/test_custom_class1.cpp
+++ b/tests/json/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_custom_class2.cpp b/tests/json/test_custom_class2.cpp
index f076c40b..ee7a0745 100644
--- a/tests/json/test_custom_class2.cpp
+++ b/tests/json/test_custom_class2.cpp
@@ -1,10 +1,8 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <stdexcept>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_custom_class3.cpp b/tests/json/test_custom_class3.cpp
index 1bc68f22..14199727 100644
--- a/tests/json/test_custom_class3.cpp
+++ b/tests/json/test_custom_class3.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_custom_class4.cpp b/tests/json/test_custom_class4.cpp
index 8b7b774b..18d8244c 100644
--- a/tests/json/test_custom_class4.cpp
+++ b/tests/json/test_custom_class4.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_custom_constructor.cpp b/tests/json/test_custom_constructor.cpp
index f7ac8a5b..490f40d9 100644
--- a/tests/json/test_custom_constructor.cpp
+++ b/tests/json/test_custom_constructor.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_default_if_missing.cpp b/tests/json/test_default_if_missing.cpp
index d186b011..238cb2fe 100644
--- a/tests/json/test_default_if_missing.cpp
+++ b/tests/json/test_default_if_missing.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_default_if_missing_no_field_names.cpp b/tests/json/test_default_if_missing_no_field_names.cpp
index e90a53ed..11db4f55 100644
--- a/tests/json/test_default_if_missing_no_field_names.cpp
+++ b/tests/json/test_default_if_missing_no_field_names.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_default_values.cpp b/tests/json/test_default_values.cpp
index 101b210e..0b0fcc3f 100644
--- a/tests/json/test_default_values.cpp
+++ b/tests/json/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_deque.cpp b/tests/json/test_deque.cpp
index f9c81b42..39e012ce 100644
--- a/tests/json/test_deque.cpp
+++ b/tests/json/test_deque.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_duration.cpp b/tests/json/test_duration.cpp
index 2d4655f6..2f5ead2c 100644
--- a/tests/json/test_duration.cpp
+++ b/tests/json/test_duration.cpp
@@ -1,8 +1,6 @@
 #include <chrono>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_duration_conversion.cpp b/tests/json/test_duration_conversion.cpp
index 1f59d55d..ba110df8 100644
--- a/tests/json/test_duration_conversion.cpp
+++ b/tests/json/test_duration_conversion.cpp
@@ -1,8 +1,6 @@
 #include <chrono>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_email.cpp b/tests/json/test_email.cpp
index 0567e0d6..590970cd 100644
--- a/tests/json/test_email.cpp
+++ b/tests/json/test_email.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_empty_object.cpp b/tests/json/test_empty_object.cpp
index 6ee53a86..6c722bb7 100644
--- a/tests/json/test_empty_object.cpp
+++ b/tests/json/test_empty_object.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_enum1.cpp b/tests/json/test_enum1.cpp
index c38f7ec2..346624bb 100644
--- a/tests/json/test_enum1.cpp
+++ b/tests/json/test_enum1.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_enum2.cpp b/tests/json/test_enum2.cpp
index 289c1cab..ec0e2595 100644
--- a/tests/json/test_enum2.cpp
+++ b/tests/json/test_enum2.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_enum3.cpp b/tests/json/test_enum3.cpp
index ee270835..fbf01f06 100644
--- a/tests/json/test_enum3.cpp
+++ b/tests/json/test_enum3.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_enum4.cpp b/tests/json/test_enum4.cpp
index 5b43bd60..455e9697 100644
--- a/tests/json/test_enum4.cpp
+++ b/tests/json/test_enum4.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_enum5.cpp b/tests/json/test_enum5.cpp
index 44ad5c3c..a704d764 100644
--- a/tests/json/test_enum5.cpp
+++ b/tests/json/test_enum5.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_enum6.cpp b/tests/json/test_enum6.cpp
index 46174bc8..173b8d31 100644
--- a/tests/json/test_enum6.cpp
+++ b/tests/json/test_enum6.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_enum7.cpp b/tests/json/test_enum7.cpp
index 644e4d9f..1a9776fe 100644
--- a/tests/json/test_enum7.cpp
+++ b/tests/json/test_enum7.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include <gtest/gtest.h>
 
diff --git a/tests/json/test_error_messages.cpp b/tests/json/test_error_messages.cpp
index 4e7387a4..1b919522 100644
--- a/tests/json/test_error_messages.cpp
+++ b/tests/json/test_error_messages.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_extra_fields.cpp b/tests/json/test_extra_fields.cpp
index 1ad31989..f5d152e8 100644
--- a/tests/json/test_extra_fields.cpp
+++ b/tests/json/test_extra_fields.cpp
@@ -1,9 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_extra_fields_with_no_extra_fields.cpp b/tests/json/test_extra_fields_with_no_extra_fields.cpp
index 86e747e9..9a8e64ca 100644
--- a/tests/json/test_extra_fields_with_no_extra_fields.cpp
+++ b/tests/json/test_extra_fields_with_no_extra_fields.cpp
@@ -1,9 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_field_variant.cpp b/tests/json/test_field_variant.cpp
index ed2fdcf6..f89363e2 100644
--- a/tests/json/test_field_variant.cpp
+++ b/tests/json/test_field_variant.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_field_variant_std.cpp b/tests/json/test_field_variant_std.cpp
index f5e14b3a..0ea90f01 100644
--- a/tests/json/test_field_variant_std.cpp
+++ b/tests/json/test_field_variant_std.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_filepath.cpp b/tests/json/test_filepath.cpp
index 07f30ca3..f9de556f 100644
--- a/tests/json/test_filepath.cpp
+++ b/tests/json/test_filepath.cpp
@@ -1,9 +1,7 @@
 #include <filesystem>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_flag_enum1.cpp b/tests/json/test_flag_enum1.cpp
index ece68eaa..c141066f 100644
--- a/tests/json/test_flag_enum1.cpp
+++ b/tests/json/test_flag_enum1.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_flag_enum2.cpp b/tests/json/test_flag_enum2.cpp
index 34241a8b..ef2f71f1 100644
--- a/tests/json/test_flag_enum2.cpp
+++ b/tests/json/test_flag_enum2.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_flag_enum_with_int.cpp b/tests/json/test_flag_enum_with_int.cpp
index 47938ee3..5fa44e2d 100644
--- a/tests/json/test_flag_enum_with_int.cpp
+++ b/tests/json/test_flag_enum_with_int.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_flatten.cpp b/tests/json/test_flatten.cpp
index 6a617199..f8a5425d 100644
--- a/tests/json/test_flatten.cpp
+++ b/tests/json/test_flatten.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_flatten_anonymous.cpp b/tests/json/test_flatten_anonymous.cpp
index d6a18bdf..e0d900b9 100644
--- a/tests/json/test_flatten_anonymous.cpp
+++ b/tests/json/test_flatten_anonymous.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_forward_list.cpp b/tests/json/test_forward_list.cpp
index e565b9b6..7477d58a 100644
--- a/tests/json/test_forward_list.cpp
+++ b/tests/json/test_forward_list.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_generic.cpp b/tests/json/test_generic.cpp
index 547c624d..1fda1954 100644
--- a/tests/json/test_generic.cpp
+++ b/tests/json/test_generic.cpp
@@ -1,9 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_generic2.cpp b/tests/json/test_generic2.cpp
index e16b2555..6830006d 100644
--- a/tests/json/test_generic2.cpp
+++ b/tests/json/test_generic2.cpp
@@ -1,9 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_hex.cpp b/tests/json/test_hex.cpp
index 3f4a480e..4bd52689 100644
--- a/tests/json/test_hex.cpp
+++ b/tests/json/test_hex.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_inside_function.cpp b/tests/json/test_inside_function.cpp
index 9df80c48..d27a7510 100644
--- a/tests/json/test_inside_function.cpp
+++ b/tests/json/test_inside_function.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_json_schema.cpp b/tests/json/test_json_schema.cpp
index bfbfe3dc..2360a113 100644
--- a/tests/json/test_json_schema.cpp
+++ b/tests/json/test_json_schema.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_json_schema2.cpp b/tests/json/test_json_schema2.cpp
index 3ab3a927..a47f4387 100644
--- a/tests/json/test_json_schema2.cpp
+++ b/tests/json/test_json_schema2.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_json_schema3.cpp b/tests/json/test_json_schema3.cpp
index 2bbe5759..7fed1943 100644
--- a/tests/json/test_json_schema3.cpp
+++ b/tests/json/test_json_schema3.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_json_schema4.cpp b/tests/json/test_json_schema4.cpp
index 9518c33a..e094eb86 100644
--- a/tests/json/test_json_schema4.cpp
+++ b/tests/json/test_json_schema4.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_json_schema5.cpp b/tests/json/test_json_schema5.cpp
index 77620b27..481c8892 100644
--- a/tests/json/test_json_schema5.cpp
+++ b/tests/json/test_json_schema5.cpp
@@ -1,10 +1,7 @@
-#include <iostream>
 #include <optional>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <tuple>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_json_schema_size_validation.cpp b/tests/json/test_json_schema_size_validation.cpp
index db1b2d59..97e3b5bc 100644
--- a/tests/json/test_json_schema_size_validation.cpp
+++ b/tests/json/test_json_schema_size_validation.cpp
@@ -1,4 +1,3 @@
-#include <array>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <set>
diff --git a/tests/json/test_leak.cpp b/tests/json/test_leak.cpp
index f9b3378f..32275d8e 100644
--- a/tests/json/test_leak.cpp
+++ b/tests/json/test_leak.cpp
@@ -1,9 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_leak_arr.cpp b/tests/json/test_leak_arr.cpp
index 5ce29dd8..943df9df 100644
--- a/tests/json/test_leak_arr.cpp
+++ b/tests/json/test_leak_arr.cpp
@@ -1,9 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_leak_rfl_tup.cpp b/tests/json/test_leak_rfl_tup.cpp
index 1f73246d..59a4ffe9 100644
--- a/tests/json/test_leak_rfl_tup.cpp
+++ b/tests/json/test_leak_rfl_tup.cpp
@@ -1,9 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_leak_tup.cpp b/tests/json/test_leak_tup.cpp
index aba8d70c..82ce358a 100644
--- a/tests/json/test_leak_tup.cpp
+++ b/tests/json/test_leak_tup.cpp
@@ -1,10 +1,7 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <source_location>
 #include <string>
 #include <tuple>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_list.cpp b/tests/json/test_list.cpp
index 8166b0f2..2378658b 100644
--- a/tests/json/test_list.cpp
+++ b/tests/json/test_list.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_literal.cpp b/tests/json/test_literal.cpp
index 58d51da1..372820c6 100644
--- a/tests/json/test_literal.cpp
+++ b/tests/json/test_literal.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_literal_map.cpp b/tests/json/test_literal_map.cpp
index 3220cbab..2c1f5342 100644
--- a/tests/json/test_literal_map.cpp
+++ b/tests/json/test_literal_map.cpp
@@ -1,10 +1,8 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_literal_unordered_map.cpp b/tests/json/test_literal_unordered_map.cpp
index dfca39b4..8cae2dea 100644
--- a/tests/json/test_literal_unordered_map.cpp
+++ b/tests/json/test_literal_unordered_map.cpp
@@ -1,6 +1,3 @@
-#include <functional>
-#include <iostream>
-#include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_map.cpp b/tests/json/test_map.cpp
index 63c8ab44..e4054a9f 100644
--- a/tests/json/test_map.cpp
+++ b/tests/json/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_map_with_key_validation.cpp b/tests/json/test_map_with_key_validation.cpp
index 0c1906c6..36ad8290 100644
--- a/tests/json/test_map_with_key_validation.cpp
+++ b/tests/json/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_meta_fields.cpp b/tests/json/test_meta_fields.cpp
index 04000212..28e6a788 100644
--- a/tests/json/test_meta_fields.cpp
+++ b/tests/json/test_meta_fields.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 
 #include <gtest/gtest.h>
diff --git a/tests/json/test_monster_example.cpp b/tests/json/test_monster_example.cpp
index 3b3f375b..6a1a927b 100644
--- a/tests/json/test_monster_example.cpp
+++ b/tests/json/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_movable.cpp b/tests/json/test_movable.cpp
index 6bc420e2..44565a5a 100644
--- a/tests/json/test_movable.cpp
+++ b/tests/json/test_movable.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_move_replace.cpp b/tests/json/test_move_replace.cpp
index d724ae2b..fe95f204 100644
--- a/tests/json/test_move_replace.cpp
+++ b/tests/json/test_move_replace.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_multimap.cpp b/tests/json/test_multimap.cpp
index d4cf506b..8fad5853 100644
--- a/tests/json/test_multimap.cpp
+++ b/tests/json/test_multimap.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_multiset.cpp b/tests/json/test_multiset.cpp
index 27004585..c303145f 100644
--- a/tests/json/test_multiset.cpp
+++ b/tests/json/test_multiset.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_named_tuple.cpp b/tests/json/test_named_tuple.cpp
index 1ab33497..30cc7fa4 100644
--- a/tests/json/test_named_tuple.cpp
+++ b/tests/json/test_named_tuple.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_no_extra_fields.cpp b/tests/json/test_no_extra_fields.cpp
index 511a8da0..7c668bd8 100644
--- a/tests/json/test_no_extra_fields.cpp
+++ b/tests/json/test_no_extra_fields.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_no_extra_fields_with_default.cpp b/tests/json/test_no_extra_fields_with_default.cpp
index 7b5b3937..96f8a288 100644
--- a/tests/json/test_no_extra_fields_with_default.cpp
+++ b/tests/json/test_no_extra_fields_with_default.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_no_optionals.cpp b/tests/json/test_no_optionals.cpp
index 8d560aea..0617a064 100644
--- a/tests/json/test_no_optionals.cpp
+++ b/tests/json/test_no_optionals.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_object.cpp b/tests/json/test_object.cpp
index c40bbfd4..bf43b74e 100644
--- a/tests/json/test_object.cpp
+++ b/tests/json/test_object.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_oct.cpp b/tests/json/test_oct.cpp
index 4c4a634d..2a75ef0a 100644
--- a/tests/json/test_oct.cpp
+++ b/tests/json/test_oct.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_one_of.cpp b/tests/json/test_one_of.cpp
index 9d798431..0c104cbb 100644
--- a/tests/json/test_one_of.cpp
+++ b/tests/json/test_one_of.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_optional_fields.cpp b/tests/json/test_optional_fields.cpp
index 248b9aea..e7d183de 100644
--- a/tests/json/test_optional_fields.cpp
+++ b/tests/json/test_optional_fields.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_pointer_fields.cpp b/tests/json/test_pointer_fields.cpp
index 68b0584a..bebc58a5 100644
--- a/tests/json/test_pointer_fields.cpp
+++ b/tests/json/test_pointer_fields.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_readme_example.cpp b/tests/json/test_readme_example.cpp
index 6b406b3b..3dc5653d 100644
--- a/tests/json/test_readme_example.cpp
+++ b/tests/json/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_ref.cpp b/tests/json/test_ref.cpp
index abe32967..44906546 100644
--- a/tests/json/test_ref.cpp
+++ b/tests/json/test_ref.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_replace.cpp b/tests/json/test_replace.cpp
index 11df8121..cbeac626 100644
--- a/tests/json/test_replace.cpp
+++ b/tests/json/test_replace.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_replace2.cpp b/tests/json/test_replace2.cpp
index dc6a8b0a..7a4d5a17 100644
--- a/tests/json/test_replace2.cpp
+++ b/tests/json/test_replace2.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_replace_flatten.cpp b/tests/json/test_replace_flatten.cpp
index 1b347768..b7ab4186 100644
--- a/tests/json/test_replace_flatten.cpp
+++ b/tests/json/test_replace_flatten.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_replace_flatten2.cpp b/tests/json/test_replace_flatten2.cpp
index 95e174da..43c08301 100644
--- a/tests/json/test_replace_flatten2.cpp
+++ b/tests/json/test_replace_flatten2.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_replace_with_other_struct.cpp b/tests/json/test_replace_with_other_struct.cpp
index 5bc483ea..e0f529c7 100644
--- a/tests/json/test_replace_with_other_struct.cpp
+++ b/tests/json/test_replace_with_other_struct.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_replace_with_other_struct2.cpp b/tests/json/test_replace_with_other_struct2.cpp
index 7d6f89f0..bb576a35 100644
--- a/tests/json/test_replace_with_other_struct2.cpp
+++ b/tests/json/test_replace_with_other_struct2.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_result.cpp b/tests/json/test_result.cpp
index b72c767e..ba47369c 100644
--- a/tests/json/test_result.cpp
+++ b/tests/json/test_result.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_rfl_tuple.cpp b/tests/json/test_rfl_tuple.cpp
index d9d342fe..21cbe30a 100644
--- a/tests/json/test_rfl_tuple.cpp
+++ b/tests/json/test_rfl_tuple.cpp
@@ -3,7 +3,6 @@
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <tuple>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant.cpp b/tests/json/test_rfl_variant.cpp
index eb43aed9..b1ac4d58 100644
--- a/tests/json/test_rfl_variant.cpp
+++ b/tests/json/test_rfl_variant.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant_emplace.cpp b/tests/json/test_rfl_variant_emplace.cpp
index cec11f00..fba28b18 100644
--- a/tests/json/test_rfl_variant_emplace.cpp
+++ b/tests/json/test_rfl_variant_emplace.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant_get_if.cpp b/tests/json/test_rfl_variant_get_if.cpp
index 2dd4a160..893e1ce7 100644
--- a/tests/json/test_rfl_variant_get_if.cpp
+++ b/tests/json/test_rfl_variant_get_if.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant_holds_alternative.cpp b/tests/json/test_rfl_variant_holds_alternative.cpp
index be1936dc..6d2971b0 100644
--- a/tests/json/test_rfl_variant_holds_alternative.cpp
+++ b/tests/json/test_rfl_variant_holds_alternative.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant_swap.cpp b/tests/json/test_rfl_variant_swap.cpp
index 894ec1a9..723d8c63 100644
--- a/tests/json/test_rfl_variant_swap.cpp
+++ b/tests/json/test_rfl_variant_swap.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant_visit.cpp b/tests/json/test_rfl_variant_visit.cpp
index 9d05cba6..01859e6d 100644
--- a/tests/json/test_rfl_variant_visit.cpp
+++ b/tests/json/test_rfl_variant_visit.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant_visit_in_place.cpp b/tests/json/test_rfl_variant_visit_in_place.cpp
index bafee19a..43f672c3 100644
--- a/tests/json/test_rfl_variant_visit_in_place.cpp
+++ b/tests/json/test_rfl_variant_visit_in_place.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_rfl_variant_visit_lvalues.cpp b/tests/json/test_rfl_variant_visit_lvalues.cpp
index 3eecc815..0697fb1c 100644
--- a/tests/json/test_rfl_variant_visit_lvalues.cpp
+++ b/tests/json/test_rfl_variant_visit_lvalues.cpp
@@ -1,9 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_segfault.cpp b/tests/json/test_segfault.cpp
index cd2ce656..56137b5d 100644
--- a/tests/json/test_segfault.cpp
+++ b/tests/json/test_segfault.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_set.cpp b/tests/json/test_set.cpp
index 68b5bce2..8afc04ec 100644
--- a/tests/json/test_set.cpp
+++ b/tests/json/test_set.cpp
@@ -1,8 +1,7 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
+#include <set>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_shared_ptr.cpp b/tests/json/test_shared_ptr.cpp
index 7a024151..7af63514 100644
--- a/tests/json/test_shared_ptr.cpp
+++ b/tests/json/test_shared_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_size.cpp b/tests/json/test_size.cpp
index d9df3224..c7babbd5 100644
--- a/tests/json/test_size.cpp
+++ b/tests/json/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_skip.cpp b/tests/json/test_skip.cpp
index a964dc80..802bb6e2 100644
--- a/tests/json/test_skip.cpp
+++ b/tests/json/test_skip.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_skip2.cpp b/tests/json/test_skip2.cpp
index 50d8273b..3c744936 100644
--- a/tests/json/test_skip2.cpp
+++ b/tests/json/test_skip2.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_snake_case_to_camel_case.cpp b/tests/json/test_snake_case_to_camel_case.cpp
index 39334c84..cd8dfde0 100644
--- a/tests/json/test_snake_case_to_camel_case.cpp
+++ b/tests/json/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_snake_case_to_camel_case_rename.cpp b/tests/json/test_snake_case_to_camel_case_rename.cpp
index 6068e4dc..e5850b2c 100644
--- a/tests/json/test_snake_case_to_camel_case_rename.cpp
+++ b/tests/json/test_snake_case_to_camel_case_rename.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_snake_case_to_pascal_case.cpp b/tests/json/test_snake_case_to_pascal_case.cpp
index dcff91c5..2a88cec7 100644
--- a/tests/json/test_snake_case_to_pascal_case.cpp
+++ b/tests/json/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_snake_case_to_pascal_case_rename.cpp b/tests/json/test_snake_case_to_pascal_case_rename.cpp
index 1884d945..c4cda458 100644
--- a/tests/json/test_snake_case_to_pascal_case_rename.cpp
+++ b/tests/json/test_snake_case_to_pascal_case_rename.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_span.cpp b/tests/json/test_span.cpp
index 534d0a12..a29e698f 100644
--- a/tests/json/test_span.cpp
+++ b/tests/json/test_span.cpp
@@ -1,5 +1,4 @@
 #include <iostream>
-#include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <span>
diff --git a/tests/json/test_string_map.cpp b/tests/json/test_string_map.cpp
index 345d00c1..84515c27 100644
--- a/tests/json/test_string_map.cpp
+++ b/tests/json/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/json/test_string_unordered_map.cpp b/tests/json/test_string_unordered_map.cpp
index 8ebbc7e9..76658770 100644
--- a/tests/json/test_string_unordered_map.cpp
+++ b/tests/json/test_string_unordered_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_string_view.cpp b/tests/json/test_string_view.cpp
index e82759da..a92f2582 100644
--- a/tests/json/test_string_view.cpp
+++ b/tests/json/test_string_view.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include <functional>
 #include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_strip_field_names.cpp b/tests/json/test_strip_field_names.cpp
index 1d299d3c..eda633fc 100644
--- a/tests/json/test_strip_field_names.cpp
+++ b/tests/json/test_strip_field_names.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_tagged_union.cpp b/tests/json/test_tagged_union.cpp
index 73ce76c7..12f2098f 100644
--- a/tests/json/test_tagged_union.cpp
+++ b/tests/json/test_tagged_union.cpp
@@ -1,9 +1,5 @@
-#include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_tagged_union2.cpp b/tests/json/test_tagged_union2.cpp
index 2d3cc0cb..a0d3a73d 100644
--- a/tests/json/test_tagged_union2.cpp
+++ b/tests/json/test_tagged_union2.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_tagged_union3.cpp b/tests/json/test_tagged_union3.cpp
index db9c503e..f0e2f437 100644
--- a/tests/json/test_tagged_union3.cpp
+++ b/tests/json/test_tagged_union3.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_tagged_union4.cpp b/tests/json/test_tagged_union4.cpp
index 108358b3..a1ba70c6 100644
--- a/tests/json/test_tagged_union4.cpp
+++ b/tests/json/test_tagged_union4.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_tagged_union5.cpp b/tests/json/test_tagged_union5.cpp
index 90d6e5d7..27181cb1 100644
--- a/tests/json/test_tagged_union5.cpp
+++ b/tests/json/test_tagged_union5.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include <gtest/gtest.h>
 
diff --git a/tests/json/test_template.cpp b/tests/json/test_template.cpp
index ee93074a..93ddad65 100644
--- a/tests/json/test_template.cpp
+++ b/tests/json/test_template.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_timestamp.cpp b/tests/json/test_timestamp.cpp
index 264244e7..0c91fb74 100644
--- a/tests/json/test_timestamp.cpp
+++ b/tests/json/test_timestamp.cpp
@@ -1,9 +1,6 @@
-#include <ctime>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_transform.cpp b/tests/json/test_transform.cpp
index a0703fa0..4909720d 100644
--- a/tests/json/test_transform.cpp
+++ b/tests/json/test_transform.cpp
@@ -1,10 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <type_traits>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_underlying_enums.cpp b/tests/json/test_underlying_enums.cpp
index c2f58ea7..3634a4d9 100644
--- a/tests/json/test_underlying_enums.cpp
+++ b/tests/json/test_underlying_enums.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_unique_ptr.cpp b/tests/json/test_unique_ptr.cpp
index b5dc8901..075505c1 100644
--- a/tests/json/test_unique_ptr.cpp
+++ b/tests/json/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/json/test_unique_ptr2.cpp b/tests/json/test_unique_ptr2.cpp
index 356cb32a..125dff51 100644
--- a/tests/json/test_unique_ptr2.cpp
+++ b/tests/json/test_unique_ptr2.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_unnamed_namespace.cpp b/tests/json/test_unnamed_namespace.cpp
index a03e7be8..29d70efa 100644
--- a/tests/json/test_unnamed_namespace.cpp
+++ b/tests/json/test_unnamed_namespace.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_unordered_map.cpp b/tests/json/test_unordered_map.cpp
index b14df3a4..756ae355 100644
--- a/tests/json/test_unordered_map.cpp
+++ b/tests/json/test_unordered_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_unordered_map_with_custom_hash.cpp b/tests/json/test_unordered_map_with_custom_hash.cpp
index c38c47c4..7b57e3c0 100644
--- a/tests/json/test_unordered_map_with_custom_hash.cpp
+++ b/tests/json/test_unordered_map_with_custom_hash.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_unordered_multimap.cpp b/tests/json/test_unordered_multimap.cpp
index 833f0045..d405a9f8 100644
--- a/tests/json/test_unordered_multimap.cpp
+++ b/tests/json/test_unordered_multimap.cpp
@@ -1,5 +1,3 @@
-#include <iostream>
-#include <map>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json/test_unordered_multiset.cpp b/tests/json/test_unordered_multiset.cpp
index 68dfeabb..656d65de 100644
--- a/tests/json/test_unordered_multiset.cpp
+++ b/tests/json/test_unordered_multiset.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_unordered_set.cpp b/tests/json/test_unordered_set.cpp
index e33c3fc5..1037dee2 100644
--- a/tests/json/test_unordered_set.cpp
+++ b/tests/json/test_unordered_set.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_uuid.cpp b/tests/json/test_uuid.cpp
index 8c26f028..56e8d2b2 100644
--- a/tests/json/test_uuid.cpp
+++ b/tests/json/test_uuid.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_variant.cpp b/tests/json/test_variant.cpp
index 31147d5a..c467cd53 100644
--- a/tests/json/test_variant.cpp
+++ b/tests/json/test_variant.cpp
@@ -1,9 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_view.cpp b/tests/json/test_view.cpp
index ca090fe2..eb25c8dc 100644
--- a/tests/json/test_view.cpp
+++ b/tests/json/test_view.cpp
@@ -1,10 +1,7 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <type_traits>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/json/test_wstring.cpp b/tests/json/test_wstring.cpp
index 6987eae7..10c178be 100644
--- a/tests/json/test_wstring.cpp
+++ b/tests/json/test_wstring.cpp
@@ -1,6 +1,4 @@
-#include <iostream>
 #include <map>
-#include <memory>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/json_c_arrays_and_inheritance/test_c_array_class1.cpp b/tests/json_c_arrays_and_inheritance/test_c_array_class1.cpp
index 1034c3f8..6eec4aa7 100644
--- a/tests/json_c_arrays_and_inheritance/test_c_array_class1.cpp
+++ b/tests/json_c_arrays_and_inheritance/test_c_array_class1.cpp
@@ -1,7 +1,7 @@
 #include <string>
 
-#include "rfl.hpp"
-#include "rfl/json.hpp"
+//#include "rfl.hpp"
+//#include "rfl/json.hpp"
 #include "write_and_read.hpp"
 
 namespace test_c_array_class1 {
diff --git a/tests/json_c_arrays_and_inheritance/test_c_array_class2.cpp b/tests/json_c_arrays_and_inheritance/test_c_array_class2.cpp
index 485c3ab9..ef889fe9 100644
--- a/tests/json_c_arrays_and_inheritance/test_c_array_class2.cpp
+++ b/tests/json_c_arrays_and_inheritance/test_c_array_class2.cpp
@@ -1,7 +1,7 @@
 #include <string>
 
-#include "rfl.hpp"
-#include "rfl/json.hpp"
+//#include "rfl.hpp"
+//#include "rfl/json.hpp"
 #include "write_and_read.hpp"
 
 namespace test_c_array_class2 {
diff --git a/tests/json_c_arrays_and_inheritance/test_c_array_class3.cpp b/tests/json_c_arrays_and_inheritance/test_c_array_class3.cpp
index 50cdce08..d4d77bc1 100644
--- a/tests/json_c_arrays_and_inheritance/test_c_array_class3.cpp
+++ b/tests/json_c_arrays_and_inheritance/test_c_array_class3.cpp
@@ -1,7 +1,7 @@
 #include <array>
 
-#include "rfl.hpp"
-#include "rfl/json.hpp"
+//#include "rfl.hpp"
+//#include "rfl/json.hpp"
 #include "write_and_read.hpp"
 
 namespace test_c_array_class3 {
diff --git a/tests/json_c_arrays_and_inheritance/test_c_array_class4.cpp b/tests/json_c_arrays_and_inheritance/test_c_array_class4.cpp
index fc71d1cf..9a770d46 100644
--- a/tests/json_c_arrays_and_inheritance/test_c_array_class4.cpp
+++ b/tests/json_c_arrays_and_inheritance/test_c_array_class4.cpp
@@ -1,7 +1,7 @@
-#include <array>
+//#include <array>
 
-#include "rfl.hpp"
-#include "rfl/json.hpp"
+//#include "rfl.hpp"
+//#include "rfl/json.hpp"
 #include "write_and_read.hpp"
 
 namespace test_c_array_class4 {
diff --git a/tests/json_c_arrays_and_inheritance/test_c_array_class5.cpp b/tests/json_c_arrays_and_inheritance/test_c_array_class5.cpp
index 58fe2573..cfa90923 100644
--- a/tests/json_c_arrays_and_inheritance/test_c_array_class5.cpp
+++ b/tests/json_c_arrays_and_inheritance/test_c_array_class5.cpp
@@ -1,7 +1,7 @@
-#include <array>
+//#include <array>
 
-#include "rfl.hpp"
-#include "rfl/json.hpp"
+//#include "rfl.hpp"
+//#include "rfl/json.hpp"
 #include "write_and_read.hpp"
 
 namespace test_c_array_class5 {
diff --git a/tests/json_c_arrays_and_inheritance/test_inheritance.cpp b/tests/json_c_arrays_and_inheritance/test_inheritance.cpp
index 9bcdbf99..88379ccf 100644
--- a/tests/json_c_arrays_and_inheritance/test_inheritance.cpp
+++ b/tests/json_c_arrays_and_inheritance/test_inheritance.cpp
@@ -1,9 +1,7 @@
 #include <gtest/gtest.h>
 
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <tuple>
 
 namespace test_inheritance {
 
diff --git a/tests/json_c_arrays_and_inheritance/test_inheritance2.cpp b/tests/json_c_arrays_and_inheritance/test_inheritance2.cpp
index 0bc67055..e79b3541 100644
--- a/tests/json_c_arrays_and_inheritance/test_inheritance2.cpp
+++ b/tests/json_c_arrays_and_inheritance/test_inheritance2.cpp
@@ -1,7 +1,6 @@
 #include <gtest/gtest.h>
 
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 
 #include "rfl/num_fields.hpp"
diff --git a/tests/msgpack/test_add_struct_name.cpp b/tests/msgpack/test_add_struct_name.cpp
index bc0dc8f7..9b43f397 100644
--- a/tests/msgpack/test_add_struct_name.cpp
+++ b/tests/msgpack/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/msgpack/test_array.cpp b/tests/msgpack/test_array.cpp
index c95b3e70..bb694bb5 100644
--- a/tests/msgpack/test_array.cpp
+++ b/tests/msgpack/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/msgpack.hpp>
 #include <string>
diff --git a/tests/msgpack/test_box.cpp b/tests/msgpack/test_box.cpp
index 73bc7ff8..bb2737c4 100644
--- a/tests/msgpack/test_box.cpp
+++ b/tests/msgpack/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_bytestring.cpp b/tests/msgpack/test_bytestring.cpp
index 33d7ec17..efb1d68a 100644
--- a/tests/msgpack/test_bytestring.cpp
+++ b/tests/msgpack/test_bytestring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_combined_processors.cpp b/tests/msgpack/test_combined_processors.cpp
index 60819435..e2e2b779 100644
--- a/tests/msgpack/test_combined_processors.cpp
+++ b/tests/msgpack/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/msgpack/test_custom_class1.cpp b/tests/msgpack/test_custom_class1.cpp
index 50ea75a3..69f86afa 100644
--- a/tests/msgpack/test_custom_class1.cpp
+++ b/tests/msgpack/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/msgpack/test_custom_class3.cpp b/tests/msgpack/test_custom_class3.cpp
index e6990dfd..0b94d239 100644
--- a/tests/msgpack/test_custom_class3.cpp
+++ b/tests/msgpack/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_custom_class4.cpp b/tests/msgpack/test_custom_class4.cpp
index e851f3df..f944367d 100644
--- a/tests/msgpack/test_custom_class4.cpp
+++ b/tests/msgpack/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_default_values.cpp b/tests/msgpack/test_default_values.cpp
index ffc3a9e0..582529a5 100644
--- a/tests/msgpack/test_default_values.cpp
+++ b/tests/msgpack/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/msgpack/test_deque.cpp b/tests/msgpack/test_deque.cpp
index ab268480..4b8eae7c 100644
--- a/tests/msgpack/test_deque.cpp
+++ b/tests/msgpack/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_enum.cpp b/tests/msgpack/test_enum.cpp
index aac38bb6..dddbab8e 100644
--- a/tests/msgpack/test_enum.cpp
+++ b/tests/msgpack/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_extra_fields.cpp b/tests/msgpack/test_extra_fields.cpp
index fe43dccf..0633031e 100644
--- a/tests/msgpack/test_extra_fields.cpp
+++ b/tests/msgpack/test_extra_fields.cpp
@@ -1,8 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_field_variant.cpp b/tests/msgpack/test_field_variant.cpp
index 1298e7c0..06d44edf 100644
--- a/tests/msgpack/test_field_variant.cpp
+++ b/tests/msgpack/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_flag_enum.cpp b/tests/msgpack/test_flag_enum.cpp
index af69453a..25996b18 100644
--- a/tests/msgpack/test_flag_enum.cpp
+++ b/tests/msgpack/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_flag_enum_with_int.cpp b/tests/msgpack/test_flag_enum_with_int.cpp
index 24f99aac..46473a8a 100644
--- a/tests/msgpack/test_flag_enum_with_int.cpp
+++ b/tests/msgpack/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_flatten.cpp b/tests/msgpack/test_flatten.cpp
index 0b64e740..07c5594a 100644
--- a/tests/msgpack/test_flatten.cpp
+++ b/tests/msgpack/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_flatten_anonymous.cpp b/tests/msgpack/test_flatten_anonymous.cpp
index c72c539d..b25ec9ee 100644
--- a/tests/msgpack/test_flatten_anonymous.cpp
+++ b/tests/msgpack/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_forward_list.cpp b/tests/msgpack/test_forward_list.cpp
index 90d9b3f3..88079396 100644
--- a/tests/msgpack/test_forward_list.cpp
+++ b/tests/msgpack/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_generic_float.cpp b/tests/msgpack/test_generic_float.cpp
index 49d9e30f..c23f6756 100644
--- a/tests/msgpack/test_generic_float.cpp
+++ b/tests/msgpack/test_generic_float.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_literal.cpp b/tests/msgpack/test_literal.cpp
index e148eb28..2eaf117c 100644
--- a/tests/msgpack/test_literal.cpp
+++ b/tests/msgpack/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/msgpack/test_literal_map.cpp b/tests/msgpack/test_literal_map.cpp
index 729a3381..5b0bf148 100644
--- a/tests/msgpack/test_literal_map.cpp
+++ b/tests/msgpack/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_map.cpp b/tests/msgpack/test_map.cpp
index bbddf520..1736704a 100644
--- a/tests/msgpack/test_map.cpp
+++ b/tests/msgpack/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/msgpack/test_map_with_key_validation.cpp b/tests/msgpack/test_map_with_key_validation.cpp
index 8caa206a..072b530b 100644
--- a/tests/msgpack/test_map_with_key_validation.cpp
+++ b/tests/msgpack/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/msgpack/test_monster_example.cpp b/tests/msgpack/test_monster_example.cpp
index 2f17abc6..60def237 100644
--- a/tests/msgpack/test_monster_example.cpp
+++ b/tests/msgpack/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/msgpack/test_readme_example.cpp b/tests/msgpack/test_readme_example.cpp
index 84407895..ef57bf70 100644
--- a/tests/msgpack/test_readme_example.cpp
+++ b/tests/msgpack/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/msgpack/test_readme_example2.cpp b/tests/msgpack/test_readme_example2.cpp
index d5c03c69..10633487 100644
--- a/tests/msgpack/test_readme_example2.cpp
+++ b/tests/msgpack/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_ref.cpp b/tests/msgpack/test_ref.cpp
index 04aa8b02..f56e1cdd 100644
--- a/tests/msgpack/test_ref.cpp
+++ b/tests/msgpack/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_save_load.cpp b/tests/msgpack/test_save_load.cpp
index 7854e7e9..a5c34bf1 100644
--- a/tests/msgpack/test_save_load.cpp
+++ b/tests/msgpack/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/msgpack.hpp>
 #include <string>
diff --git a/tests/msgpack/test_set.cpp b/tests/msgpack/test_set.cpp
index 200f8398..2115eeb8 100644
--- a/tests/msgpack/test_set.cpp
+++ b/tests/msgpack/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_size.cpp b/tests/msgpack/test_size.cpp
index b5dc7565..d368ec62 100644
--- a/tests/msgpack/test_size.cpp
+++ b/tests/msgpack/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/msgpack/test_skip.cpp b/tests/msgpack/test_skip.cpp
index 16a21cae..428df860 100644
--- a/tests/msgpack/test_skip.cpp
+++ b/tests/msgpack/test_skip.cpp
@@ -1,6 +1,4 @@
-#include <iostream>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_snake_case_to_camel_case.cpp b/tests/msgpack/test_snake_case_to_camel_case.cpp
index 1efd4198..ba65e5d4 100644
--- a/tests/msgpack/test_snake_case_to_camel_case.cpp
+++ b/tests/msgpack/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/msgpack/test_snake_case_to_pascal_case.cpp b/tests/msgpack/test_snake_case_to_pascal_case.cpp
index 26254092..c0cd8f10 100644
--- a/tests/msgpack/test_snake_case_to_pascal_case.cpp
+++ b/tests/msgpack/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/msgpack/test_string_map.cpp b/tests/msgpack/test_string_map.cpp
index f020a45d..da6a46ef 100644
--- a/tests/msgpack/test_string_map.cpp
+++ b/tests/msgpack/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/msgpack/test_tagged_union.cpp b/tests/msgpack/test_tagged_union.cpp
index 421dd003..9d951400 100644
--- a/tests/msgpack/test_tagged_union.cpp
+++ b/tests/msgpack/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_tagged_union2.cpp b/tests/msgpack/test_tagged_union2.cpp
index afc4e1f9..5c5022cd 100644
--- a/tests/msgpack/test_tagged_union2.cpp
+++ b/tests/msgpack/test_tagged_union2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_timestamp.cpp b/tests/msgpack/test_timestamp.cpp
index 5d865d73..ab2a81db 100644
--- a/tests/msgpack/test_timestamp.cpp
+++ b/tests/msgpack/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_unique_ptr.cpp b/tests/msgpack/test_unique_ptr.cpp
index 028fffe3..5dff3ab2 100644
--- a/tests/msgpack/test_unique_ptr.cpp
+++ b/tests/msgpack/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/msgpack/test_unique_ptr2.cpp b/tests/msgpack/test_unique_ptr2.cpp
index 7b501835..ec11bfcc 100644
--- a/tests/msgpack/test_unique_ptr2.cpp
+++ b/tests/msgpack/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_variant.cpp b/tests/msgpack/test_variant.cpp
index cb623d11..76353ed7 100644
--- a/tests/msgpack/test_variant.cpp
+++ b/tests/msgpack/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_vectorstring.cpp b/tests/msgpack/test_vectorstring.cpp
index 11e83a67..2a9dd7d4 100644
--- a/tests/msgpack/test_vectorstring.cpp
+++ b/tests/msgpack/test_vectorstring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/test_wstring.cpp b/tests/msgpack/test_wstring.cpp
index 773c3b86..f69be6d1 100644
--- a/tests/msgpack/test_wstring.cpp
+++ b/tests/msgpack/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/msgpack/write_and_read.hpp b/tests/msgpack/write_and_read.hpp
index f122c6cc..23b62820 100644
--- a/tests/msgpack/write_and_read.hpp
+++ b/tests/msgpack/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/msgpack.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/parquet/test_boolean.cpp b/tests/parquet/test_boolean.cpp
index e01f1ad3..8f8d125f 100644
--- a/tests/parquet/test_boolean.cpp
+++ b/tests/parquet/test_boolean.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_box.cpp b/tests/parquet/test_box.cpp
index 8fd5098a..2a468b6d 100644
--- a/tests/parquet/test_box.cpp
+++ b/tests/parquet/test_box.cpp
@@ -1,5 +1,3 @@
-#include <iostream>
-#include <memory>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_bytestring.cpp b/tests/parquet/test_bytestring.cpp
index 55e9f4e8..56d85f1e 100644
--- a/tests/parquet/test_bytestring.cpp
+++ b/tests/parquet/test_bytestring.cpp
@@ -1,6 +1,4 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/parquet/test_camel_case.cpp b/tests/parquet/test_camel_case.cpp
index 7eeffa30..c36cfde5 100644
--- a/tests/parquet/test_camel_case.cpp
+++ b/tests/parquet/test_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_deque.cpp b/tests/parquet/test_deque.cpp
index 41b40ab8..6fd0a637 100644
--- a/tests/parquet/test_deque.cpp
+++ b/tests/parquet/test_deque.cpp
@@ -1,5 +1,4 @@
 #include <deque>
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 
diff --git a/tests/parquet/test_enums.cpp b/tests/parquet/test_enums.cpp
index ff3b2091..cc512606 100644
--- a/tests/parquet/test_enums.cpp
+++ b/tests/parquet/test_enums.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_flatten.cpp b/tests/parquet/test_flatten.cpp
index 4c7c12e1..93c7345f 100644
--- a/tests/parquet/test_flatten.cpp
+++ b/tests/parquet/test_flatten.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_gzip.cpp b/tests/parquet/test_gzip.cpp
index ee254395..62f45f7f 100644
--- a/tests/parquet/test_gzip.cpp
+++ b/tests/parquet/test_gzip.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_literal.cpp b/tests/parquet/test_literal.cpp
index 1e36b6ca..ad021fb7 100644
--- a/tests/parquet/test_literal.cpp
+++ b/tests/parquet/test_literal.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_optionals.cpp b/tests/parquet/test_optionals.cpp
index b5d3df80..a070494b 100644
--- a/tests/parquet/test_optionals.cpp
+++ b/tests/parquet/test_optionals.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <optional>
 #include <rfl/parquet.hpp>
 #include <string>
diff --git a/tests/parquet/test_readme_example.cpp b/tests/parquet/test_readme_example.cpp
index 48fc082c..6a5b0db2 100644
--- a/tests/parquet/test_readme_example.cpp
+++ b/tests/parquet/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_ref.cpp b/tests/parquet/test_ref.cpp
index 03417a85..a7e405b5 100644
--- a/tests/parquet/test_ref.cpp
+++ b/tests/parquet/test_ref.cpp
@@ -1,5 +1,3 @@
-#include <iostream>
-#include <memory>
 #include <rfl/parquet.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/parquet/test_save_load.cpp b/tests/parquet/test_save_load.cpp
index fe760dc6..3b5c0d41 100644
--- a/tests/parquet/test_save_load.cpp
+++ b/tests/parquet/test_save_load.cpp
@@ -1,7 +1,6 @@
 #include <gtest/gtest.h>
 
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/parquet.hpp>
 #include <string>
diff --git a/tests/parquet/test_shared_ptr.cpp b/tests/parquet/test_shared_ptr.cpp
index 09f9c6e7..dce923e7 100644
--- a/tests/parquet/test_shared_ptr.cpp
+++ b/tests/parquet/test_shared_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl/parquet.hpp>
 #include <string>
diff --git a/tests/parquet/test_unique_ptr.cpp b/tests/parquet/test_unique_ptr.cpp
index 1df85ffa..18b7a504 100644
--- a/tests/parquet/test_unique_ptr.cpp
+++ b/tests/parquet/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl/parquet.hpp>
 #include <string>
diff --git a/tests/parquet/write_and_read.hpp b/tests/parquet/write_and_read.hpp
index 53ee3b9c..4ec554ea 100644
--- a/tests/parquet/write_and_read.hpp
+++ b/tests/parquet/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/parquet.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _vec, const rfl::parquet::Settings& _settings =
diff --git a/tests/toml/test_add_struct_name.cpp b/tests/toml/test_add_struct_name.cpp
index 51e94e0e..de354e45 100644
--- a/tests/toml/test_add_struct_name.cpp
+++ b/tests/toml/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/toml/test_array.cpp b/tests/toml/test_array.cpp
index f9d8bd8b..76b65961 100644
--- a/tests/toml/test_array.cpp
+++ b/tests/toml/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/toml.hpp>
 #include <string>
diff --git a/tests/toml/test_box.cpp b/tests/toml/test_box.cpp
index 6f5b9e43..724986de 100644
--- a/tests/toml/test_box.cpp
+++ b/tests/toml/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_combined_processors.cpp b/tests/toml/test_combined_processors.cpp
index a74a41aa..39aaf28b 100644
--- a/tests/toml/test_combined_processors.cpp
+++ b/tests/toml/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/toml/test_custom_class1.cpp b/tests/toml/test_custom_class1.cpp
index 145c89b1..e3109aed 100644
--- a/tests/toml/test_custom_class1.cpp
+++ b/tests/toml/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/toml/test_custom_class3.cpp b/tests/toml/test_custom_class3.cpp
index f42f7290..c623f6f6 100644
--- a/tests/toml/test_custom_class3.cpp
+++ b/tests/toml/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_custom_class4.cpp b/tests/toml/test_custom_class4.cpp
index 02b8e8d0..89b8b6a2 100644
--- a/tests/toml/test_custom_class4.cpp
+++ b/tests/toml/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_default_values.cpp b/tests/toml/test_default_values.cpp
index b97b9086..c68b8335 100644
--- a/tests/toml/test_default_values.cpp
+++ b/tests/toml/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/toml/test_deque.cpp b/tests/toml/test_deque.cpp
index f2492cc7..8f628188 100644
--- a/tests/toml/test_deque.cpp
+++ b/tests/toml/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_enum.cpp b/tests/toml/test_enum.cpp
index 87d00710..a556b5ed 100644
--- a/tests/toml/test_enum.cpp
+++ b/tests/toml/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_field_variant.cpp b/tests/toml/test_field_variant.cpp
index bcabfd42..a1bf430c 100644
--- a/tests/toml/test_field_variant.cpp
+++ b/tests/toml/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_flag_enum.cpp b/tests/toml/test_flag_enum.cpp
index 2d63ef6b..6c8dd04b 100644
--- a/tests/toml/test_flag_enum.cpp
+++ b/tests/toml/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_flag_enum_with_int.cpp b/tests/toml/test_flag_enum_with_int.cpp
index 0b36b15b..b983d22f 100644
--- a/tests/toml/test_flag_enum_with_int.cpp
+++ b/tests/toml/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_flatten.cpp b/tests/toml/test_flatten.cpp
index 5180d57f..53f3df9f 100644
--- a/tests/toml/test_flatten.cpp
+++ b/tests/toml/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_flatten_anonymous.cpp b/tests/toml/test_flatten_anonymous.cpp
index 3d387203..f4040a63 100644
--- a/tests/toml/test_flatten_anonymous.cpp
+++ b/tests/toml/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_forward_list.cpp b/tests/toml/test_forward_list.cpp
index d1c99d46..6c9eba57 100644
--- a/tests/toml/test_forward_list.cpp
+++ b/tests/toml/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_literal.cpp b/tests/toml/test_literal.cpp
index fcd0929c..da59008d 100644
--- a/tests/toml/test_literal.cpp
+++ b/tests/toml/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/toml/test_literal_map.cpp b/tests/toml/test_literal_map.cpp
index 07faad45..ee6c3f5a 100644
--- a/tests/toml/test_literal_map.cpp
+++ b/tests/toml/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_map.cpp b/tests/toml/test_map.cpp
index db797e67..7a42d8b4 100644
--- a/tests/toml/test_map.cpp
+++ b/tests/toml/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/toml/test_map_with_key_validation.cpp b/tests/toml/test_map_with_key_validation.cpp
index 234c5caf..205b5e73 100644
--- a/tests/toml/test_map_with_key_validation.cpp
+++ b/tests/toml/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/toml/test_monster_example.cpp b/tests/toml/test_monster_example.cpp
index 1a404fdf..5d846df4 100644
--- a/tests/toml/test_monster_example.cpp
+++ b/tests/toml/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/toml/test_readme_example.cpp b/tests/toml/test_readme_example.cpp
index 10df2654..a9f00fbf 100644
--- a/tests/toml/test_readme_example.cpp
+++ b/tests/toml/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/toml/test_readme_example2.cpp b/tests/toml/test_readme_example2.cpp
index 6f534905..b4407b48 100644
--- a/tests/toml/test_readme_example2.cpp
+++ b/tests/toml/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_ref.cpp b/tests/toml/test_ref.cpp
index 942b05e0..7bec77f7 100644
--- a/tests/toml/test_ref.cpp
+++ b/tests/toml/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_save_load.cpp b/tests/toml/test_save_load.cpp
index 9082d2e7..81dd09d5 100644
--- a/tests/toml/test_save_load.cpp
+++ b/tests/toml/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/toml.hpp>
 #include <string>
diff --git a/tests/toml/test_set.cpp b/tests/toml/test_set.cpp
index 7a4331d8..3814ac3d 100644
--- a/tests/toml/test_set.cpp
+++ b/tests/toml/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_size.cpp b/tests/toml/test_size.cpp
index b2b6bd49..f045ab80 100644
--- a/tests/toml/test_size.cpp
+++ b/tests/toml/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/toml/test_snake_case_to_camel_case.cpp b/tests/toml/test_snake_case_to_camel_case.cpp
index c9561e87..5aea8b53 100644
--- a/tests/toml/test_snake_case_to_camel_case.cpp
+++ b/tests/toml/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/toml/test_snake_case_to_pascal_case.cpp b/tests/toml/test_snake_case_to_pascal_case.cpp
index a22320e7..63e786b6 100644
--- a/tests/toml/test_snake_case_to_pascal_case.cpp
+++ b/tests/toml/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/toml/test_string_map.cpp b/tests/toml/test_string_map.cpp
index 5e47403e..c7739a60 100644
--- a/tests/toml/test_string_map.cpp
+++ b/tests/toml/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/toml/test_tagged_union.cpp b/tests/toml/test_tagged_union.cpp
index 66bad9cc..4b14c543 100644
--- a/tests/toml/test_tagged_union.cpp
+++ b/tests/toml/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_timestamp.cpp b/tests/toml/test_timestamp.cpp
index ca9ea5da..b8fb0c3f 100644
--- a/tests/toml/test_timestamp.cpp
+++ b/tests/toml/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_unique_ptr.cpp b/tests/toml/test_unique_ptr.cpp
index b0a749f8..f1ab2cad 100644
--- a/tests/toml/test_unique_ptr.cpp
+++ b/tests/toml/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/toml/test_unique_ptr2.cpp b/tests/toml/test_unique_ptr2.cpp
index 21572b24..294e3b2a 100644
--- a/tests/toml/test_unique_ptr2.cpp
+++ b/tests/toml/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_variant.cpp b/tests/toml/test_variant.cpp
index 89183c7f..5812a5d5 100644
--- a/tests/toml/test_variant.cpp
+++ b/tests/toml/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/test_wstring.cpp b/tests/toml/test_wstring.cpp
index 32a48767..6dccf690 100644
--- a/tests/toml/test_wstring.cpp
+++ b/tests/toml/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/toml/write_and_read.hpp b/tests/toml/write_and_read.hpp
index 2fde07cd..c7c53c84 100644
--- a/tests/toml/write_and_read.hpp
+++ b/tests/toml/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/toml.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/ubjson/test_add_struct_name.cpp b/tests/ubjson/test_add_struct_name.cpp
index 3e5238b9..08faff5e 100644
--- a/tests/ubjson/test_add_struct_name.cpp
+++ b/tests/ubjson/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/ubjson/test_array.cpp b/tests/ubjson/test_array.cpp
index 08308e73..5c680886 100644
--- a/tests/ubjson/test_array.cpp
+++ b/tests/ubjson/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/ubjson.hpp>
 #include <string>
diff --git a/tests/ubjson/test_box.cpp b/tests/ubjson/test_box.cpp
index 2388f964..13431adc 100644
--- a/tests/ubjson/test_box.cpp
+++ b/tests/ubjson/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_bytestring.cpp b/tests/ubjson/test_bytestring.cpp
index c1c2c4a5..a0eb74bb 100644
--- a/tests/ubjson/test_bytestring.cpp
+++ b/tests/ubjson/test_bytestring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_combined_processors.cpp b/tests/ubjson/test_combined_processors.cpp
index 73224238..2ad0e5af 100644
--- a/tests/ubjson/test_combined_processors.cpp
+++ b/tests/ubjson/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/ubjson/test_custom_class1.cpp b/tests/ubjson/test_custom_class1.cpp
index 290abb1a..b187e1f7 100644
--- a/tests/ubjson/test_custom_class1.cpp
+++ b/tests/ubjson/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/ubjson/test_custom_class3.cpp b/tests/ubjson/test_custom_class3.cpp
index 380791fd..4dd84fe3 100644
--- a/tests/ubjson/test_custom_class3.cpp
+++ b/tests/ubjson/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_custom_class4.cpp b/tests/ubjson/test_custom_class4.cpp
index 74240ec9..e3aacdf1 100644
--- a/tests/ubjson/test_custom_class4.cpp
+++ b/tests/ubjson/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_default_values.cpp b/tests/ubjson/test_default_values.cpp
index a2e18bb9..4d889980 100644
--- a/tests/ubjson/test_default_values.cpp
+++ b/tests/ubjson/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/ubjson/test_deque.cpp b/tests/ubjson/test_deque.cpp
index 0ea6b0fc..00021f2e 100644
--- a/tests/ubjson/test_deque.cpp
+++ b/tests/ubjson/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_enum.cpp b/tests/ubjson/test_enum.cpp
index c383f3c7..cdfda67f 100644
--- a/tests/ubjson/test_enum.cpp
+++ b/tests/ubjson/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_error_messages.cpp b/tests/ubjson/test_error_messages.cpp
index ee461a0a..41fd1210 100644
--- a/tests/ubjson/test_error_messages.cpp
+++ b/tests/ubjson/test_error_messages.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/ubjson.hpp>
 #include <rfl/json.hpp>
diff --git a/tests/ubjson/test_extra_fields.cpp b/tests/ubjson/test_extra_fields.cpp
index a8e203c7..04cc5b76 100644
--- a/tests/ubjson/test_extra_fields.cpp
+++ b/tests/ubjson/test_extra_fields.cpp
@@ -1,8 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <source_location>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_field_variant.cpp b/tests/ubjson/test_field_variant.cpp
index 496f171b..041ec2eb 100644
--- a/tests/ubjson/test_field_variant.cpp
+++ b/tests/ubjson/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_flag_enum.cpp b/tests/ubjson/test_flag_enum.cpp
index 75806f80..580979fc 100644
--- a/tests/ubjson/test_flag_enum.cpp
+++ b/tests/ubjson/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_flag_enum_with_int.cpp b/tests/ubjson/test_flag_enum_with_int.cpp
index ed461e69..15da8931 100644
--- a/tests/ubjson/test_flag_enum_with_int.cpp
+++ b/tests/ubjson/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_flatten.cpp b/tests/ubjson/test_flatten.cpp
index 17011232..75eb6ec9 100644
--- a/tests/ubjson/test_flatten.cpp
+++ b/tests/ubjson/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_flatten_anonymous.cpp b/tests/ubjson/test_flatten_anonymous.cpp
index 2211045a..56e82cc2 100644
--- a/tests/ubjson/test_flatten_anonymous.cpp
+++ b/tests/ubjson/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_forward_list.cpp b/tests/ubjson/test_forward_list.cpp
index 86546394..12282ffd 100644
--- a/tests/ubjson/test_forward_list.cpp
+++ b/tests/ubjson/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_literal.cpp b/tests/ubjson/test_literal.cpp
index 84b3e499..cb096741 100644
--- a/tests/ubjson/test_literal.cpp
+++ b/tests/ubjson/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/ubjson/test_literal_map.cpp b/tests/ubjson/test_literal_map.cpp
index 65cd54cc..27e4a609 100644
--- a/tests/ubjson/test_literal_map.cpp
+++ b/tests/ubjson/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_map.cpp b/tests/ubjson/test_map.cpp
index 63533005..309638bf 100644
--- a/tests/ubjson/test_map.cpp
+++ b/tests/ubjson/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/ubjson/test_map_with_key_validation.cpp b/tests/ubjson/test_map_with_key_validation.cpp
index ee9f08e6..fc6a2635 100644
--- a/tests/ubjson/test_map_with_key_validation.cpp
+++ b/tests/ubjson/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/ubjson/test_monster_example.cpp b/tests/ubjson/test_monster_example.cpp
index 09c19dec..0de32ead 100644
--- a/tests/ubjson/test_monster_example.cpp
+++ b/tests/ubjson/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/ubjson/test_readme_example.cpp b/tests/ubjson/test_readme_example.cpp
index f8fc7a58..a64bfe95 100644
--- a/tests/ubjson/test_readme_example.cpp
+++ b/tests/ubjson/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/ubjson/test_readme_example2.cpp b/tests/ubjson/test_readme_example2.cpp
index 80ddc01f..0cf3bcb3 100644
--- a/tests/ubjson/test_readme_example2.cpp
+++ b/tests/ubjson/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_ref.cpp b/tests/ubjson/test_ref.cpp
index 254d0743..ca7a15c0 100644
--- a/tests/ubjson/test_ref.cpp
+++ b/tests/ubjson/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_save_load.cpp b/tests/ubjson/test_save_load.cpp
index 4fff2b24..28159abb 100644
--- a/tests/ubjson/test_save_load.cpp
+++ b/tests/ubjson/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/ubjson.hpp>
 #include <string>
diff --git a/tests/ubjson/test_set.cpp b/tests/ubjson/test_set.cpp
index f0e94e73..8da87e05 100644
--- a/tests/ubjson/test_set.cpp
+++ b/tests/ubjson/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_size.cpp b/tests/ubjson/test_size.cpp
index 4c0e46c0..67d1ad00 100644
--- a/tests/ubjson/test_size.cpp
+++ b/tests/ubjson/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/ubjson/test_snake_case_to_camel_case.cpp b/tests/ubjson/test_snake_case_to_camel_case.cpp
index 9a5edbfa..58a4c923 100644
--- a/tests/ubjson/test_snake_case_to_camel_case.cpp
+++ b/tests/ubjson/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/ubjson/test_snake_case_to_pascal_case.cpp b/tests/ubjson/test_snake_case_to_pascal_case.cpp
index e56baf30..88142619 100644
--- a/tests/ubjson/test_snake_case_to_pascal_case.cpp
+++ b/tests/ubjson/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/ubjson/test_string_map.cpp b/tests/ubjson/test_string_map.cpp
index 3a07a821..5803989a 100644
--- a/tests/ubjson/test_string_map.cpp
+++ b/tests/ubjson/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/ubjson/test_tagged_union.cpp b/tests/ubjson/test_tagged_union.cpp
index 9af0678c..654b5cd1 100644
--- a/tests/ubjson/test_tagged_union.cpp
+++ b/tests/ubjson/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_tagged_union2.cpp b/tests/ubjson/test_tagged_union2.cpp
index 779a58fb..906ee14e 100644
--- a/tests/ubjson/test_tagged_union2.cpp
+++ b/tests/ubjson/test_tagged_union2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_timestamp.cpp b/tests/ubjson/test_timestamp.cpp
index 7805e30e..26f3ad10 100644
--- a/tests/ubjson/test_timestamp.cpp
+++ b/tests/ubjson/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_unique_ptr.cpp b/tests/ubjson/test_unique_ptr.cpp
index 0e4ca7dc..04594545 100644
--- a/tests/ubjson/test_unique_ptr.cpp
+++ b/tests/ubjson/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/ubjson/test_unique_ptr2.cpp b/tests/ubjson/test_unique_ptr2.cpp
index a23c8b78..fa9d48c7 100644
--- a/tests/ubjson/test_unique_ptr2.cpp
+++ b/tests/ubjson/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_variant.cpp b/tests/ubjson/test_variant.cpp
index 763b1803..604ffbf0 100644
--- a/tests/ubjson/test_variant.cpp
+++ b/tests/ubjson/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_vectorstring.cpp b/tests/ubjson/test_vectorstring.cpp
index 7e7c44ff..4e1f6a36 100644
--- a/tests/ubjson/test_vectorstring.cpp
+++ b/tests/ubjson/test_vectorstring.cpp
@@ -1,7 +1,4 @@
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/test_wstring.cpp b/tests/ubjson/test_wstring.cpp
index 2c3bb625..07bbe3fd 100644
--- a/tests/ubjson/test_wstring.cpp
+++ b/tests/ubjson/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/ubjson/write_and_read.hpp b/tests/ubjson/write_and_read.hpp
index 50e5b33b..dd9aed63 100644
--- a/tests/ubjson/write_and_read.hpp
+++ b/tests/ubjson/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/ubjson.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/xml/test_add_struct_name.cpp b/tests/xml/test_add_struct_name.cpp
index 66da5b91..0f0819fa 100644
--- a/tests/xml/test_add_struct_name.cpp
+++ b/tests/xml/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/xml/test_array.cpp b/tests/xml/test_array.cpp
index e0e8531a..8d5f6f1f 100644
--- a/tests/xml/test_array.cpp
+++ b/tests/xml/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/xml.hpp>
 #include <string>
diff --git a/tests/xml/test_attribute_rename.cpp b/tests/xml/test_attribute_rename.cpp
index c5326771..22be8e9a 100644
--- a/tests/xml/test_attribute_rename.cpp
+++ b/tests/xml/test_attribute_rename.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/xml/test_box.cpp b/tests/xml/test_box.cpp
index fa9b4dd0..969b2d2f 100644
--- a/tests/xml/test_box.cpp
+++ b/tests/xml/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_combined_processors.cpp b/tests/xml/test_combined_processors.cpp
index 455424e0..38022a38 100644
--- a/tests/xml/test_combined_processors.cpp
+++ b/tests/xml/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/xml/test_custom_class1.cpp b/tests/xml/test_custom_class1.cpp
index 61dce08d..a3b70887 100644
--- a/tests/xml/test_custom_class1.cpp
+++ b/tests/xml/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/xml/test_custom_class3.cpp b/tests/xml/test_custom_class3.cpp
index 12f8d9ed..88c52969 100644
--- a/tests/xml/test_custom_class3.cpp
+++ b/tests/xml/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_custom_class4.cpp b/tests/xml/test_custom_class4.cpp
index a6cee66f..493b58c1 100644
--- a/tests/xml/test_custom_class4.cpp
+++ b/tests/xml/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_default_if_missing.cpp b/tests/xml/test_default_if_missing.cpp
index 9d7d1fe3..36c3bbb9 100644
--- a/tests/xml/test_default_if_missing.cpp
+++ b/tests/xml/test_default_if_missing.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/xml/test_default_values.cpp b/tests/xml/test_default_values.cpp
index 0b48a73b..19e8da67 100644
--- a/tests/xml/test_default_values.cpp
+++ b/tests/xml/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/xml/test_deque.cpp b/tests/xml/test_deque.cpp
index 55ea1808..57876ed8 100644
--- a/tests/xml/test_deque.cpp
+++ b/tests/xml/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_enum.cpp b/tests/xml/test_enum.cpp
index 581b94ff..662ecf67 100644
--- a/tests/xml/test_enum.cpp
+++ b/tests/xml/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_field_variant.cpp b/tests/xml/test_field_variant.cpp
index 2c4dfcc4..c6d85a8c 100644
--- a/tests/xml/test_field_variant.cpp
+++ b/tests/xml/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_flag_enum.cpp b/tests/xml/test_flag_enum.cpp
index 035d6360..4bb39c8a 100644
--- a/tests/xml/test_flag_enum.cpp
+++ b/tests/xml/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_flag_enum_with_int.cpp b/tests/xml/test_flag_enum_with_int.cpp
index 0ff5f727..410ecd5a 100644
--- a/tests/xml/test_flag_enum_with_int.cpp
+++ b/tests/xml/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_flatten.cpp b/tests/xml/test_flatten.cpp
index fc06c2aa..a144acae 100644
--- a/tests/xml/test_flatten.cpp
+++ b/tests/xml/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_flatten_anonymous.cpp b/tests/xml/test_flatten_anonymous.cpp
index 105aa11e..04bab2b2 100644
--- a/tests/xml/test_flatten_anonymous.cpp
+++ b/tests/xml/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_forward_list.cpp b/tests/xml/test_forward_list.cpp
index 31be1c52..e2294378 100644
--- a/tests/xml/test_forward_list.cpp
+++ b/tests/xml/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_literal.cpp b/tests/xml/test_literal.cpp
index 72513298..cf37158f 100644
--- a/tests/xml/test_literal.cpp
+++ b/tests/xml/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/xml/test_literal_map.cpp b/tests/xml/test_literal_map.cpp
index 1e652e01..170da094 100644
--- a/tests/xml/test_literal_map.cpp
+++ b/tests/xml/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_map.cpp b/tests/xml/test_map.cpp
index 537993e9..de38548d 100644
--- a/tests/xml/test_map.cpp
+++ b/tests/xml/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/xml/test_map_with_key_validation.cpp b/tests/xml/test_map_with_key_validation.cpp
index 6d0e0dc0..646ecb03 100644
--- a/tests/xml/test_map_with_key_validation.cpp
+++ b/tests/xml/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/xml/test_monster_example.cpp b/tests/xml/test_monster_example.cpp
index dcc00f40..910b76e5 100644
--- a/tests/xml/test_monster_example.cpp
+++ b/tests/xml/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/xml/test_readme_example.cpp b/tests/xml/test_readme_example.cpp
index 99d7faa0..8ef27abc 100644
--- a/tests/xml/test_readme_example.cpp
+++ b/tests/xml/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/xml/test_readme_example2.cpp b/tests/xml/test_readme_example2.cpp
index 7f4aab69..b16b7b6d 100644
--- a/tests/xml/test_readme_example2.cpp
+++ b/tests/xml/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_ref.cpp b/tests/xml/test_ref.cpp
index ba5a075a..320ce069 100644
--- a/tests/xml/test_ref.cpp
+++ b/tests/xml/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_save_load.cpp b/tests/xml/test_save_load.cpp
index 1a3d2722..c1a7ad56 100644
--- a/tests/xml/test_save_load.cpp
+++ b/tests/xml/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/xml.hpp>
 #include <string>
diff --git a/tests/xml/test_set.cpp b/tests/xml/test_set.cpp
index 5dc0bdb9..49025c95 100644
--- a/tests/xml/test_set.cpp
+++ b/tests/xml/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_size.cpp b/tests/xml/test_size.cpp
index 153fb269..30429a90 100644
--- a/tests/xml/test_size.cpp
+++ b/tests/xml/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/xml/test_snake_case_to_camel_case.cpp b/tests/xml/test_snake_case_to_camel_case.cpp
index 3e3f18db..8fb5f6b8 100644
--- a/tests/xml/test_snake_case_to_camel_case.cpp
+++ b/tests/xml/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/xml/test_snake_case_to_pascal_case.cpp b/tests/xml/test_snake_case_to_pascal_case.cpp
index 4f02ec14..86cd8ef2 100644
--- a/tests/xml/test_snake_case_to_pascal_case.cpp
+++ b/tests/xml/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/xml/test_string_map.cpp b/tests/xml/test_string_map.cpp
index dc713650..1cb5f280 100644
--- a/tests/xml/test_string_map.cpp
+++ b/tests/xml/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/xml/test_tagged_union.cpp b/tests/xml/test_tagged_union.cpp
index 88b4874d..5c3c8348 100644
--- a/tests/xml/test_tagged_union.cpp
+++ b/tests/xml/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_timestamp.cpp b/tests/xml/test_timestamp.cpp
index 26b7b9dd..2566596c 100644
--- a/tests/xml/test_timestamp.cpp
+++ b/tests/xml/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_unique_ptr.cpp b/tests/xml/test_unique_ptr.cpp
index cae7661d..41e9d46f 100644
--- a/tests/xml/test_unique_ptr.cpp
+++ b/tests/xml/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/xml/test_unique_ptr2.cpp b/tests/xml/test_unique_ptr2.cpp
index 8ccc0fcc..2d209d4e 100644
--- a/tests/xml/test_unique_ptr2.cpp
+++ b/tests/xml/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_variant.cpp b/tests/xml/test_variant.cpp
index 89ce3178..a61eedaa 100644
--- a/tests/xml/test_variant.cpp
+++ b/tests/xml/test_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_wstring.cpp b/tests/xml/test_wstring.cpp
index 8d336d5a..c855a913 100644
--- a/tests/xml/test_wstring.cpp
+++ b/tests/xml/test_wstring.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/xml/test_xml_content.cpp b/tests/xml/test_xml_content.cpp
index 3e2797eb..c9ec3ef0 100644
--- a/tests/xml/test_xml_content.cpp
+++ b/tests/xml/test_xml_content.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/xml/test_xml_content2.cpp b/tests/xml/test_xml_content2.cpp
index 8bd6373e..0a4d74ab 100644
--- a/tests/xml/test_xml_content2.cpp
+++ b/tests/xml/test_xml_content2.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
diff --git a/tests/xml/write_and_read.hpp b/tests/xml/write_and_read.hpp
index 8fbce474..3c6c4717 100644
--- a/tests/xml/write_and_read.hpp
+++ b/tests/xml/write_and_read.hpp
@@ -3,10 +3,8 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/xml.hpp>
-#include <string>
 
 template <rfl::internal::StringLiteral _root_name = rfl::internal::StringLiteral(""), class... Ps>
 void write_and_read(const auto& _struct) {
diff --git a/tests/yaml/test_add_struct_name.cpp b/tests/yaml/test_add_struct_name.cpp
index f81e84fc..172532ab 100644
--- a/tests/yaml/test_add_struct_name.cpp
+++ b/tests/yaml/test_add_struct_name.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/yaml/test_array.cpp b/tests/yaml/test_array.cpp
index 9a59fab5..98318a10 100644
--- a/tests/yaml/test_array.cpp
+++ b/tests/yaml/test_array.cpp
@@ -1,5 +1,4 @@
 #include <array>
-#include <iostream>
 #include <memory>
 #include <rfl/yaml.hpp>
 #include <string>
diff --git a/tests/yaml/test_box.cpp b/tests/yaml/test_box.cpp
index d71b55bc..fc04dcec 100644
--- a/tests/yaml/test_box.cpp
+++ b/tests/yaml/test_box.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_combined_processors.cpp b/tests/yaml/test_combined_processors.cpp
index 7273e17e..b66b13bf 100644
--- a/tests/yaml/test_combined_processors.cpp
+++ b/tests/yaml/test_combined_processors.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/yaml/test_custom_class1.cpp b/tests/yaml/test_custom_class1.cpp
index 8ca5d72f..cd361a00 100644
--- a/tests/yaml/test_custom_class1.cpp
+++ b/tests/yaml/test_custom_class1.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/yaml/test_custom_class3.cpp b/tests/yaml/test_custom_class3.cpp
index 98ec0b7e..d5e44b8c 100644
--- a/tests/yaml/test_custom_class3.cpp
+++ b/tests/yaml/test_custom_class3.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_custom_class4.cpp b/tests/yaml/test_custom_class4.cpp
index 132e17c1..e1209fb1 100644
--- a/tests/yaml/test_custom_class4.cpp
+++ b/tests/yaml/test_custom_class4.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_default_values.cpp b/tests/yaml/test_default_values.cpp
index 2e733423..2653a4a5 100644
--- a/tests/yaml/test_default_values.cpp
+++ b/tests/yaml/test_default_values.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/yaml/test_deque.cpp b/tests/yaml/test_deque.cpp
index ff2524dc..c48d7af2 100644
--- a/tests/yaml/test_deque.cpp
+++ b/tests/yaml/test_deque.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_double.cpp b/tests/yaml/test_double.cpp
index da2247f6..7a6d5e26 100644
--- a/tests/yaml/test_double.cpp
+++ b/tests/yaml/test_double.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_enum.cpp b/tests/yaml/test_enum.cpp
index bee31639..da149a90 100644
--- a/tests/yaml/test_enum.cpp
+++ b/tests/yaml/test_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_field_variant.cpp b/tests/yaml/test_field_variant.cpp
index 0abaf4bc..8d23b057 100644
--- a/tests/yaml/test_field_variant.cpp
+++ b/tests/yaml/test_field_variant.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_flag_enum.cpp b/tests/yaml/test_flag_enum.cpp
index cfab127d..91c80c37 100644
--- a/tests/yaml/test_flag_enum.cpp
+++ b/tests/yaml/test_flag_enum.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_flag_enum_with_int.cpp b/tests/yaml/test_flag_enum_with_int.cpp
index b182a213..44411b94 100644
--- a/tests/yaml/test_flag_enum_with_int.cpp
+++ b/tests/yaml/test_flag_enum_with_int.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_flatten.cpp b/tests/yaml/test_flatten.cpp
index ef338332..b5b5f6f2 100644
--- a/tests/yaml/test_flatten.cpp
+++ b/tests/yaml/test_flatten.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_flatten_anonymous.cpp b/tests/yaml/test_flatten_anonymous.cpp
index ee4d604a..456ebb15 100644
--- a/tests/yaml/test_flatten_anonymous.cpp
+++ b/tests/yaml/test_flatten_anonymous.cpp
@@ -1,8 +1,6 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_forward_list.cpp b/tests/yaml/test_forward_list.cpp
index 964cf6c1..60255cbb 100644
--- a/tests/yaml/test_forward_list.cpp
+++ b/tests/yaml/test_forward_list.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_literal.cpp b/tests/yaml/test_literal.cpp
index 33e1f7a4..d9804cac 100644
--- a/tests/yaml/test_literal.cpp
+++ b/tests/yaml/test_literal.cpp
@@ -1,7 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
 #include <vector>
 
 #include "write_and_read.hpp"
diff --git a/tests/yaml/test_literal_map.cpp b/tests/yaml/test_literal_map.cpp
index 5e05ff33..f811c833 100644
--- a/tests/yaml/test_literal_map.cpp
+++ b/tests/yaml/test_literal_map.cpp
@@ -1,9 +1,7 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
-#include <unordered_map>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_map.cpp b/tests/yaml/test_map.cpp
index 9a37ef0b..25319f42 100644
--- a/tests/yaml/test_map.cpp
+++ b/tests/yaml/test_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/yaml/test_map_with_key_validation.cpp b/tests/yaml/test_map_with_key_validation.cpp
index e5886bb0..a154583f 100644
--- a/tests/yaml/test_map_with_key_validation.cpp
+++ b/tests/yaml/test_map_with_key_validation.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/yaml/test_monster_example.cpp b/tests/yaml/test_monster_example.cpp
index 6186da87..f80f1a90 100644
--- a/tests/yaml/test_monster_example.cpp
+++ b/tests/yaml/test_monster_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/yaml/test_readme_example.cpp b/tests/yaml/test_readme_example.cpp
index a1a6bf15..35ec709b 100644
--- a/tests/yaml/test_readme_example.cpp
+++ b/tests/yaml/test_readme_example.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/yaml/test_readme_example2.cpp b/tests/yaml/test_readme_example2.cpp
index 6fdaae4e..7a6d487e 100644
--- a/tests/yaml/test_readme_example2.cpp
+++ b/tests/yaml/test_readme_example2.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_ref.cpp b/tests/yaml/test_ref.cpp
index 7599e98e..558b23ee 100644
--- a/tests/yaml/test_ref.cpp
+++ b/tests/yaml/test_ref.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_save_load.cpp b/tests/yaml/test_save_load.cpp
index 3f758a47..c6e50420 100644
--- a/tests/yaml/test_save_load.cpp
+++ b/tests/yaml/test_save_load.cpp
@@ -1,5 +1,4 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/yaml.hpp>
 #include <string>
diff --git a/tests/yaml/test_set.cpp b/tests/yaml/test_set.cpp
index c84c479f..e40dacc2 100644
--- a/tests/yaml/test_set.cpp
+++ b/tests/yaml/test_set.cpp
@@ -1,7 +1,5 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_size.cpp b/tests/yaml/test_size.cpp
index 5a4bbf38..46efa2a3 100644
--- a/tests/yaml/test_size.cpp
+++ b/tests/yaml/test_size.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
 #include <vector>
diff --git a/tests/yaml/test_skip.cpp b/tests/yaml/test_skip.cpp
index 523007a7..d6af8a92 100644
--- a/tests/yaml/test_skip.cpp
+++ b/tests/yaml/test_skip.cpp
@@ -1,8 +1,6 @@
-#include <iostream>
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_snake_case_to_camel_case.cpp b/tests/yaml/test_snake_case_to_camel_case.cpp
index 6edabca3..04a369fc 100644
--- a/tests/yaml/test_snake_case_to_camel_case.cpp
+++ b/tests/yaml/test_snake_case_to_camel_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/yaml/test_snake_case_to_pascal_case.cpp b/tests/yaml/test_snake_case_to_pascal_case.cpp
index 46da1344..6c412456 100644
--- a/tests/yaml/test_snake_case_to_pascal_case.cpp
+++ b/tests/yaml/test_snake_case_to_pascal_case.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <string>
 #include <vector>
 
diff --git a/tests/yaml/test_string_map.cpp b/tests/yaml/test_string_map.cpp
index cfbdfa82..d8a602d8 100644
--- a/tests/yaml/test_string_map.cpp
+++ b/tests/yaml/test_string_map.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <map>
 #include <memory>
 #include <rfl.hpp>
diff --git a/tests/yaml/test_tagged_union.cpp b/tests/yaml/test_tagged_union.cpp
index 50e2d3d6..fd1760fb 100644
--- a/tests/yaml/test_tagged_union.cpp
+++ b/tests/yaml/test_tagged_union.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_timestamp.cpp b/tests/yaml/test_timestamp.cpp
index 34acdff6..9ef4a4a1 100644
--- a/tests/yaml/test_timestamp.cpp
+++ b/tests/yaml/test_timestamp.cpp
@@ -1,8 +1,6 @@
-#include <ctime>
 #include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_unique_ptr.cpp b/tests/yaml/test_unique_ptr.cpp
index bd8e2241..a0432287 100644
--- a/tests/yaml/test_unique_ptr.cpp
+++ b/tests/yaml/test_unique_ptr.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include <memory>
 #include <rfl.hpp>
 #include <string>
diff --git a/tests/yaml/test_unique_ptr2.cpp b/tests/yaml/test_unique_ptr2.cpp
index d740034d..b2a43a5b 100644
--- a/tests/yaml/test_unique_ptr2.cpp
+++ b/tests/yaml/test_unique_ptr2.cpp
@@ -1,8 +1,5 @@
 #include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_variant.cpp b/tests/yaml/test_variant.cpp
index 7722332e..53f831f5 100644
--- a/tests/yaml/test_variant.cpp
+++ b/tests/yaml/test_variant.cpp
@@ -1,8 +1,4 @@
-#include <cassert>
-#include <iostream>
 #include <rfl.hpp>
-#include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/test_wstring.cpp b/tests/yaml/test_wstring.cpp
index ff4c5dc4..ea796bfc 100644
--- a/tests/yaml/test_wstring.cpp
+++ b/tests/yaml/test_wstring.cpp
@@ -1,8 +1,5 @@
-#include <cassert>
-#include <iostream>
 #include <rfl.hpp>
 #include <string>
-#include <vector>
 
 #include "write_and_read.hpp"
 
diff --git a/tests/yaml/write_and_read.hpp b/tests/yaml/write_and_read.hpp
index 62495928..b01495e6 100644
--- a/tests/yaml/write_and_read.hpp
+++ b/tests/yaml/write_and_read.hpp
@@ -3,9 +3,7 @@
 
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <rfl/yaml.hpp>
-#include <string>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {