diff --git a/.github/workflows/build_windows.yml b/.github/workflows/build_windows.yml
index d00afdd..bf1e865 100644
--- a/.github/workflows/build_windows.yml
+++ b/.github/workflows/build_windows.yml
@@ -16,8 +16,12 @@ jobs:
         - { os: "windows-2022", msvc-toolset: "v142", cxx-standard: "17", build-type: "Release" }
         - { os: "windows-2022", msvc-toolset: "v142", cxx-standard: "17", build-type: "Debug" }
 
-        - { os: "windows-2022", mingw-version: "9.4.0", cxx-standard: "17", build-type: "Release" }
-        - { os: "windows-2022", mingw-version: "9.4.0", cxx-standard: "17", build-type: "Debug" }
+        # fires -Werror=conversion on IntWrapper default template argument
+        #- { os: "windows-2022", mingw-version: "9.4.0", cxx-standard: "17", build-type: "Release" }
+        #- { os: "windows-2022", mingw-version: "9.4.0", cxx-standard: "17", build-type: "Debug" }
+
+        - { os: "windows-2022", mingw-version: "11.2.0", cxx-standard: "17", build-type: "Release" }
+        - { os: "windows-2022", mingw-version: "11.2.0", cxx-standard: "17", build-type: "Debug" }
 
     runs-on: ${{matrix.os}}
     name: "\
diff --git a/runtime/ClangTidySuppressions.txt b/runtime/ClangTidySuppressions.txt
index dba13ab..80251cd 100644
--- a/runtime/ClangTidySuppressions.txt
+++ b/runtime/ClangTidySuppressions.txt
@@ -51,6 +51,9 @@ google-explicit-constructor:src/zserio/Span.h:138
 google-explicit-constructor:src/zserio/Span.h:150
 google-explicit-constructor:src/zserio/Span.h:163
 google-explicit-constructor:src/zserio/Span.h:176
+# This is requirement on type wrappers in Zserio C++17 extension
+google-explicit-constructor:src/zserio/Types.h:59
+google-explicit-constructor:src/zserio/Types.h:66
 
 # False positive, this is a template method.
 modernize-use-equals-default:src/zserio/Span.h:80
diff --git a/runtime/src/CMakeLists.txt b/runtime/src/CMakeLists.txt
index e6576d0..229ac0b 100644
--- a/runtime/src/CMakeLists.txt
+++ b/runtime/src/CMakeLists.txt
@@ -39,6 +39,7 @@ set(ZSERIO_CPP17_RUNTIME_LIB_SRCS
     zserio/FloatUtil.cpp
     zserio/FloatUtil.h
     zserio/HashCodeUtil.h
+    zserio/OutOfRangeException.h
     zserio/RebindAlloc.h
     zserio/RuntimeArch.h
     zserio/SizeConvertUtil.cpp
diff --git a/runtime/src/zserio/BitSizeOfCalculator.cpp b/runtime/src/zserio/BitSizeOfCalculator.cpp
index a6781bf..c377eb9 100644
--- a/runtime/src/zserio/BitSizeOfCalculator.cpp
+++ b/runtime/src/zserio/BitSizeOfCalculator.cpp
@@ -7,7 +7,7 @@
 namespace zserio
 {
 
-static const std::array<uint64_t, 2> VARIN16_MAX_VALUES = {
+static const std::array<uint64_t, 2> VARINT16_MAX_VALUES = {
         (UINT64_C(1) << (6)) - 1,
         (UINT64_C(1) << (6 + 8)) - 1,
 };
@@ -116,7 +116,7 @@ static uint64_t convertToAbsValue(T value)
 
 size_t bitSizeOfVarInt16(int16_t value)
 {
-    return bitSizeOfVarIntImpl(convertToAbsValue(value), VARIN16_MAX_VALUES, "varint16");
+    return bitSizeOfVarIntImpl(convertToAbsValue(value), VARINT16_MAX_VALUES, "varint16");
 }
 
 size_t bitSizeOfVarInt32(int32_t value)
diff --git a/runtime/src/zserio/OutOfRangeException.h b/runtime/src/zserio/OutOfRangeException.h
new file mode 100644
index 0000000..8f8c434
--- /dev/null
+++ b/runtime/src/zserio/OutOfRangeException.h
@@ -0,0 +1,20 @@
+#ifndef ZSERIO_OUT_OF_RANGE_EXCEPTION_H_INC
+#define ZSERIO_OUT_OF_RANGE_EXCEPTION_H_INC
+
+#include "zserio/CppRuntimeException.h"
+
+namespace zserio
+{
+
+/**
+ * Exception thrown when a value is out of range.
+ */
+class OutOfRangeException : public CppRuntimeException
+{
+public:
+    using CppRuntimeException::CppRuntimeException;
+};
+
+} // namespace zserio
+
+#endif // ifndef ZSERIO_OUT_OF_RANGE_EXCEPTION_H_INC
diff --git a/runtime/src/zserio/Types.h b/runtime/src/zserio/Types.h
index 928fb57..4660026 100644
--- a/runtime/src/zserio/Types.h
+++ b/runtime/src/zserio/Types.h
@@ -2,5 +2,844 @@
 #define ZSERIO_TYPES_H_INC
 
 #include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#include "zserio/OutOfRangeException.h"
+
+namespace zserio
+{
+
+/** Typedef for bit size type used in Zserio. */
+using BitSize = unsigned int;
+
+/**
+ * NumericLimits template provides a standardized way to query various properties of
+ * zserio numerical type wrappers. Inspired by std::numeric_limits.
+ *
+ * This information is provided via specializations of the NumericLimits template. All types provide information
+ * about their minimum and maximum value.
+ */
+template <typename T>
+struct NumericLimits
+{};
+
+namespace detail
+{
+
+/**
+ * Base type wrapper for all numeric types.
+ *
+ * Implements all necessary conversions and operators needed to allow to use particular type wrappers
+ * in all expressions as if they were built-in types.
+ *
+ * Limitations:
+ *
+ * * Implicit assignment between different wrapper types is not allowed.
+ */
+template <typename VALUE_TYPE>
+class NumericTypeWrapper
+{
+public:
+    /** Typedef for the underlying value type. */
+    using value_type = VALUE_TYPE;
+
+    /**
+     * Empty constructor.
+     */
+    constexpr explicit NumericTypeWrapper() noexcept :
+            m_value()
+    {}
+
+    /**
+     * Implicit constructor from underlying value type.
+     *
+     * \param value Value to construct from.
+     */
+    constexpr NumericTypeWrapper(value_type value) noexcept :
+            m_value(value)
+    {}
+
+    /**
+     * Implicit conversion to underlying value type.
+     */
+    constexpr operator value_type() const noexcept
+    {
+        return m_value;
+    }
+
+    /**
+     * Operator overload needed to allow to use particular type wrappers in all expressions as if they
+     * were built-in types.
+     *
+     * Note that overload of operator value_type&() could be used instead, but it fires a warning on gcc.
+     */
+    /** \{ */
+
+    constexpr NumericTypeWrapper& operator++() noexcept
+    {
+        ++m_value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper operator++(int) noexcept
+    {
+        NumericTypeWrapper old;
+        operator++();
+        return old;
+    }
+
+    constexpr NumericTypeWrapper& operator--() noexcept
+    {
+        --m_value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper operator--(int) noexcept
+    {
+        NumericTypeWrapper old;
+        operator--();
+        return old;
+    }
+
+    constexpr NumericTypeWrapper& operator+=(value_type value) noexcept
+    {
+        m_value += value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator-=(value_type value) noexcept
+    {
+        m_value -= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator*=(value_type value) noexcept
+    {
+        m_value *= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator/=(value_type value) noexcept
+    {
+        m_value /= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator%=(value_type value) noexcept
+    {
+        m_value %= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator&=(value_type value) noexcept
+    {
+        m_value &= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator|=(value_type value) noexcept
+    {
+        m_value |= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator^=(value_type value) noexcept
+    {
+        m_value ^= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator<<=(value_type value) noexcept
+    {
+        m_value <<= value;
+        return *this;
+    }
+
+    constexpr NumericTypeWrapper& operator>>=(value_type value) noexcept
+    {
+        m_value >>= value;
+        return *this;
+    }
+
+    /** \} */
+
+private:
+    value_type m_value;
+};
+
+class BoolWrapper : public NumericTypeWrapper<bool>
+{
+public:
+    using NumericTypeWrapper<bool>::NumericTypeWrapper;
+};
+
+template <typename VALUE_TYPE, BitSize BIT_SIZE = 8 * sizeof(VALUE_TYPE)>
+class IntWrapper : public NumericTypeWrapper<VALUE_TYPE>
+{
+private:
+    static_assert((BIT_SIZE + 7) / 8 <= sizeof(VALUE_TYPE), "BitSize doesn't fit to the VALUE_TYPE!");
+
+public:
+    using NumericTypeWrapper<VALUE_TYPE>::NumericTypeWrapper;
+};
+
+template <typename VALUE_TYPE>
+class DynIntWrapper : public IntWrapper<VALUE_TYPE>
+{
+public:
+    using IntWrapper<VALUE_TYPE>::IntWrapper;
+};
+
+enum class VarIntType : uint8_t
+{
+    VAR16,
+    VAR32,
+    VAR64,
+    VAR,
+    VARSIZE
+};
+
+template <typename VALUE_TYPE, VarIntType VAR_TYPE>
+class VarIntWrapper : public NumericTypeWrapper<VALUE_TYPE>
+{
+    static_assert(
+            VAR_TYPE != VarIntType::VARSIZE || std::is_unsigned_v<VALUE_TYPE>, "VARSIZE must be unsigned!");
+
+public:
+    using NumericTypeWrapper<VALUE_TYPE>::NumericTypeWrapper;
+};
+
+enum class FloatType : uint8_t
+{
+    FLOAT16,
+    FLOAT32,
+    FLOAT64
+};
+
+template <typename VALUE_TYPE, FloatType FLOAT_TYPE>
+class FloatWrapper : public NumericTypeWrapper<VALUE_TYPE>
+{
+public:
+    using NumericTypeWrapper<VALUE_TYPE>::NumericTypeWrapper;
+};
+
+// helper traits to check if range checking is needed (used in checkedCast)
+template <typename T>
+struct needs_range_check
+{};
+
+template <typename T>
+inline constexpr bool needs_range_check_v = needs_range_check<T>::value;
+
+template <>
+struct needs_range_check<BoolWrapper> : std::false_type
+{};
+
+template <typename VALUE_TYPE, BitSize BIT_SIZE>
+struct needs_range_check<IntWrapper<VALUE_TYPE, BIT_SIZE>>
+{
+    static constexpr bool value = !(sizeof(VALUE_TYPE) * 8 == BIT_SIZE &&
+            (BIT_SIZE == 8 || BIT_SIZE == 16 || BIT_SIZE == 32 || BIT_SIZE == 64));
+};
+
+template <typename VALUE_TYPE>
+struct needs_range_check<DynIntWrapper<VALUE_TYPE>> : std::true_type
+{};
+
+template <typename VALUE_TYPE, VarIntType VAR_TYPE>
+struct needs_range_check<VarIntWrapper<VALUE_TYPE, VAR_TYPE>>
+{
+    static constexpr bool value = VAR_TYPE != VarIntType::VAR;
+};
+
+template <typename VALUE_TYPE, FloatType FLOAT_TYPE>
+struct needs_range_check<FloatWrapper<VALUE_TYPE, FLOAT_TYPE>> : std::false_type
+{
+    // TODO[mikir]: Does it have sense to have range checking for Float16?
+};
+
+// range checker used by checkedCast, specialized for particular types when needed
+template <typename T>
+struct RangeChecker
+{
+    static constexpr void check(typename T::value_type value)
+    {
+        if constexpr (std::is_signed_v<typename T::value_type>)
+        {
+            if (value < NumericLimits<T>::min() || value > NumericLimits<T>::max())
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of range '<" << NumericLimits<T>::min() << ", "
+                        << NumericLimits<T>::max() << ">'!";
+            }
+        }
+        else
+        {
+            if (value > NumericLimits<T>::max())
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of bounds '" << NumericLimits<T>::max() << "'!";
+            }
+        }
+    }
+};
+
+template <typename VALUE_TYPE>
+struct RangeChecker<DynIntWrapper<VALUE_TYPE>>
+{
+    static constexpr void check(VALUE_TYPE value, BitSize numBits)
+    {
+        if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            if (value < NumericLimits<DynIntWrapper<VALUE_TYPE>>::min(numBits) ||
+                    value > NumericLimits<DynIntWrapper<VALUE_TYPE>>::max(numBits))
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of range '<"
+                        << NumericLimits<DynIntWrapper<VALUE_TYPE>>::min(numBits) << ", "
+                        << NumericLimits<DynIntWrapper<VALUE_TYPE>>::max(numBits) << ">'!";
+            }
+        }
+        else
+        {
+            if (value > NumericLimits<DynIntWrapper<VALUE_TYPE>>::max(numBits))
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of bounds '"
+                        << NumericLimits<DynIntWrapper<VALUE_TYPE>>::max(numBits) << "'!";
+            }
+        }
+    }
+};
+
+} // namespace detail
+
+/**
+ * Specialization of NumericLimits template for bool type wrapper.
+ */
+template <>
+struct NumericLimits<detail::BoolWrapper>
+{
+    static constexpr detail::BoolWrapper min() noexcept
+    {
+        return false;
+    }
+
+    static constexpr detail::BoolWrapper max() noexcept
+    {
+        return true;
+    }
+};
+
+/**
+ * Specialization of NumericLimits template for integral types wrapper.
+ */
+template <typename VALUE_TYPE, BitSize BIT_SIZE>
+struct NumericLimits<detail::IntWrapper<VALUE_TYPE, BIT_SIZE>>
+{
+    static constexpr detail::IntWrapper<VALUE_TYPE, BIT_SIZE> min() noexcept
+    {
+        if constexpr (!detail::needs_range_check_v<detail::IntWrapper<VALUE_TYPE, BIT_SIZE>>)
+        {
+            return std::numeric_limits<VALUE_TYPE>::min();
+        }
+        else if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            return static_cast<VALUE_TYPE>(-static_cast<VALUE_TYPE>(1ULL << (BIT_SIZE - 1U)));
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    static constexpr detail::IntWrapper<VALUE_TYPE, BIT_SIZE> max() noexcept
+    {
+        if constexpr (!detail::needs_range_check_v<detail::IntWrapper<VALUE_TYPE, BIT_SIZE>>)
+        {
+            return std::numeric_limits<VALUE_TYPE>::max();
+        }
+        else if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            return static_cast<VALUE_TYPE>((1ULL << (BIT_SIZE - 1U)) - 1U);
+        }
+        else
+        {
+            return static_cast<VALUE_TYPE>((1ULL << BIT_SIZE) - 1U);
+        }
+    }
+};
+
+/**
+ * Specialization of NumericLimits template for variable length integral types wrapper.
+ */
+template <typename VALUE_TYPE, detail::VarIntType VAR_TYPE>
+struct NumericLimits<detail::VarIntWrapper<VALUE_TYPE, VAR_TYPE>>
+{
+    static constexpr detail::VarIntWrapper<VALUE_TYPE, VAR_TYPE> min() noexcept
+    {
+        if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            if constexpr (VAR_TYPE == detail::VarIntType::VAR)
+            {
+                return std::numeric_limits<VALUE_TYPE>::min();
+            }
+            else
+            {
+                return -max();
+            }
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    static constexpr detail::VarIntWrapper<VALUE_TYPE, VAR_TYPE> max() noexcept
+    {
+        if constexpr (VAR_TYPE == detail::VarIntType::VAR16)
+        {
+            return static_cast<VALUE_TYPE>((UINT64_C(1) << (FIRST_BYTE_BITS + 8)) - 1);
+        }
+        else if constexpr (VAR_TYPE == detail::VarIntType::VAR32)
+        {
+            return static_cast<VALUE_TYPE>((UINT64_C(1) << (FIRST_BYTE_BITS + 7 + 7 + 8)) - 1);
+        }
+        else if constexpr (VAR_TYPE == detail::VarIntType::VAR64)
+        {
+            return static_cast<VALUE_TYPE>((UINT64_C(1) << (FIRST_BYTE_BITS + 7 + 7 + 7 + 7 + 7 + 7 + 8)) - 1);
+        }
+        else if constexpr (VAR_TYPE == detail::VarIntType::VAR)
+        {
+            return std::numeric_limits<VALUE_TYPE>::max();
+        }
+        else // VARSIZE
+        {
+            return (UINT64_C(1) << (2 + 7 + 7 + 7 + 8)) - 1;
+        }
+    }
+
+private:
+    static constexpr uint64_t FIRST_BYTE_BITS = std::is_signed_v<VALUE_TYPE> ? 6 : 7;
+};
+
+/**
+ * Specialization of NumericLimits template for dynamic length integral types wrapper.
+ */
+template <typename VALUE_TYPE>
+struct NumericLimits<detail::DynIntWrapper<VALUE_TYPE>>
+{
+    static constexpr detail::DynIntWrapper<VALUE_TYPE> min(BitSize numBits)
+    {
+        if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            checkNumBits(numBits);
+
+            return minSignedValue(numBits);
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    static constexpr detail::DynIntWrapper<VALUE_TYPE> max(BitSize numBits)
+    {
+        checkNumBits(numBits);
+
+        if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            return maxSignedValue(numBits);
+        }
+        else
+        {
+            return maxUnsignedValue(numBits);
+        }
+    }
+
+private:
+    static constexpr void checkNumBits(BitSize numBits)
+    {
+        if (numBits < 1 || numBits > sizeof(VALUE_TYPE) * 8)
+        {
+            throw OutOfRangeException("Dynamic bit field numBits '")
+                    << numBits << "' out of range '<1, " << sizeof(VALUE_TYPE) * 8 << ">'!";
+        }
+    }
+
+    static constexpr VALUE_TYPE minSignedValue(BitSize numBits)
+    {
+        if constexpr (std::is_same_v<VALUE_TYPE, int64_t>)
+        {
+            if (numBits == 64)
+            {
+                return INT64_MIN;
+            }
+        }
+
+        return static_cast<VALUE_TYPE>(-static_cast<VALUE_TYPE>(1ULL << (numBits - 1U)));
+    }
+
+    static constexpr VALUE_TYPE maxSignedValue(BitSize numBits)
+    {
+        if constexpr (std::is_same_v<VALUE_TYPE, int64_t>)
+        {
+            if (numBits == 64)
+            {
+                return INT64_MAX;
+            }
+        }
+
+        return static_cast<VALUE_TYPE>((1ULL << (numBits - 1U)) - 1U);
+    }
+
+    static constexpr VALUE_TYPE maxUnsignedValue(BitSize numBits)
+    {
+        if constexpr (std::is_same_v<VALUE_TYPE, uint64_t>)
+        {
+            if (numBits == 64)
+            {
+                return UINT64_MAX;
+            }
+        }
+
+        return static_cast<VALUE_TYPE>((1ULL << numBits) - 1U);
+    }
+};
+
+/**
+ * Specialization of NumericLimits template for float16 type wrapper.
+ *
+ * Hard-coded constants are used to allow the limits to be constexpr.
+ */
+template <>
+struct NumericLimits<detail::FloatWrapper<float, detail::FloatType::FLOAT16>>
+{
+    static constexpr detail::FloatWrapper<float, detail::FloatType::FLOAT16> min() noexcept
+    {
+        return 6.103515625e-05F;
+    }
+
+    static constexpr detail::FloatWrapper<float, detail::FloatType::FLOAT16> max() noexcept
+    {
+        return 65504.F;
+    }
+};
+
+/**
+ * Specialization of NumericLimits template for float32 type wrapper.
+ */
+template <>
+struct NumericLimits<detail::FloatWrapper<float, detail::FloatType::FLOAT32>>
+{
+    static constexpr detail::FloatWrapper<float, detail::FloatType::FLOAT32> min() noexcept
+    {
+        return std::numeric_limits<float>::min();
+    }
+
+    static constexpr detail::FloatWrapper<float, detail::FloatType::FLOAT32> max() noexcept
+    {
+        return std::numeric_limits<float>::max();
+    }
+};
+
+/**
+ * Specialization of NumericLimits template for float64 type wrapper.
+ */
+template <>
+struct NumericLimits<detail::FloatWrapper<double, detail::FloatType::FLOAT64>>
+{
+    static constexpr detail::FloatWrapper<double, detail::FloatType::FLOAT64> min() noexcept
+    {
+        return std::numeric_limits<double>::min();
+    }
+
+    static constexpr detail::FloatWrapper<double, detail::FloatType::FLOAT64> max() noexcept
+    {
+        return std::numeric_limits<double>::max();
+    }
+};
+
+/**
+ * Utility to safely construct zserio numeric type wrapper from its underlying value with range checking.
+ *
+ * \param value Underlying value to convert to the type wrapper.
+ *
+ * \return Numeric type wrapper constructed after range checking (if needed).
+ *
+ * \throw OutOfRangeException when the underlying value is out of range of the zserio numeric type.
+ */
+template <typename T,
+        std::enable_if_t<std::is_base_of_v<detail::NumericTypeWrapper<typename T::value_type>, T>, int> = 0>
+constexpr T fromCheckedValue(typename T::value_type value) noexcept(!detail::needs_range_check_v<T>)
+{
+    if constexpr (detail::needs_range_check_v<T>)
+    {
+        detail::RangeChecker<T>::check(value);
+    }
+
+    return T(value);
+}
+
+/**
+ * Utility to safely construct zserio numeric type wrapper from its underlying value with range checking.
+ *
+ * Overload for dynamic length types wrappers.
+ *
+ * \param value Underlying value to convert to the type wrapper.
+ * \param numBits Number of bits as a length of a dynamic length numeric type.
+ *
+ * \return Numeric type wrapper constructed after range checking (if needed).
+ *
+ * \throw OutOfRangeException when the underlying value is out of range of the zserio numeric type.
+ */
+template <typename T,
+        std::enable_if_t<std::is_base_of_v<detail::NumericTypeWrapper<typename T::value_type>, T>, int> = 0>
+constexpr T fromCheckedValue(typename T::value_type value, BitSize numBits)
+{
+    detail::RangeChecker<T>::check(value, numBits);
+
+    return T(value);
+}
+
+/**
+ * Utility to get checked underlying value from zserio numeric type wrapper.
+ *
+ * \param wrapper Numeric type wrapper to use.
+ *
+ * \return Built-in numeric type casted from numeric type wrapper after range checking (if needed).
+ *
+ * \throw OutOfRangeException when the underlying value is out of range of the zserio numeric type.
+ */
+template <typename T,
+        std::enable_if_t<std::is_base_of_v<detail::NumericTypeWrapper<typename T::value_type>, T>, int> = 0>
+constexpr typename T::value_type toCheckedValue(T wrapper) noexcept(!detail::needs_range_check_v<T>)
+{
+    if constexpr (detail::needs_range_check_v<T>)
+    {
+        detail::RangeChecker<T>::check(wrapper);
+    }
+
+    return wrapper;
+}
+
+/**
+ * Utility to get checked underlying value from zserio numeric type wrapper.
+ *
+ * Overload for dynamic length types wrappers.
+ *
+ * \param wrapper Numeric type wrapper to use.
+ * \param numBits Number of bits as a length of a dynamic length numeric type.
+ *
+ * \return Built-in numeric type casted from numeric type wrapper after range checking (if needed).
+ *
+ * \throw OutOfRangeException when the underlying value is out of range of the zserio numeric type.
+ */
+template <typename T,
+        std::enable_if_t<std::is_base_of_v<detail::NumericTypeWrapper<typename T::value_type>, T>, int> = 0>
+constexpr typename T::value_type toCheckedValue(T wrapper, BitSize numBits)
+{
+    detail::RangeChecker<T>::check(wrapper, numBits);
+
+    return wrapper;
+}
+
+/**
+ * Utility function which ensures that static_cast is called on underlying types during casting of wrappers.
+ *
+ * \param wrapper Numeric type wrapper of type T to be converted.
+ *
+ * \return Numeric type wrapper of type R.
+ */
+template <typename R, typename T,
+        std::enable_if_t<std::is_base_of_v<detail::NumericTypeWrapper<typename T::value_type>, T> &&
+                        std::is_base_of_v<detail::NumericTypeWrapper<typename R::value_type>, R>,
+                int> = 0>
+R typeCast(T wrapper)
+{
+    return static_cast<typename R::value_type>(wrapper);
+}
+
+/** Typedef for a zserio type. */
+/** \{ */
+
+using Bool = detail::BoolWrapper;
+
+using Int8 = detail::IntWrapper<int8_t>;
+using Int16 = detail::IntWrapper<int16_t>;
+using Int32 = detail::IntWrapper<int32_t>;
+using Int64 = detail::IntWrapper<int64_t, 64>;
+
+using UInt8 = detail::IntWrapper<uint8_t>;
+using UInt16 = detail::IntWrapper<uint16_t>;
+using UInt32 = detail::IntWrapper<uint32_t>;
+using UInt64 = detail::IntWrapper<uint64_t>;
+
+using Int1 = detail::IntWrapper<int8_t, 1>;
+using Int2 = detail::IntWrapper<int8_t, 2>;
+using Int3 = detail::IntWrapper<int8_t, 3>;
+using Int4 = detail::IntWrapper<int8_t, 4>;
+using Int5 = detail::IntWrapper<int8_t, 5>;
+using Int6 = detail::IntWrapper<int8_t, 6>;
+using Int7 = detail::IntWrapper<int8_t, 7>;
+using Int9 = detail::IntWrapper<int16_t, 9>;
+using Int10 = detail::IntWrapper<int16_t, 10>;
+using Int11 = detail::IntWrapper<int16_t, 11>;
+using Int12 = detail::IntWrapper<int16_t, 12>;
+using Int13 = detail::IntWrapper<int16_t, 13>;
+using Int14 = detail::IntWrapper<int16_t, 14>;
+using Int15 = detail::IntWrapper<int16_t, 15>;
+using Int17 = detail::IntWrapper<int32_t, 17>;
+using Int18 = detail::IntWrapper<int32_t, 18>;
+using Int19 = detail::IntWrapper<int32_t, 19>;
+using Int20 = detail::IntWrapper<int32_t, 20>;
+using Int21 = detail::IntWrapper<int32_t, 21>;
+using Int22 = detail::IntWrapper<int32_t, 22>;
+using Int23 = detail::IntWrapper<int32_t, 23>;
+using Int24 = detail::IntWrapper<int32_t, 24>;
+using Int25 = detail::IntWrapper<int32_t, 25>;
+using Int26 = detail::IntWrapper<int32_t, 26>;
+using Int27 = detail::IntWrapper<int32_t, 27>;
+using Int28 = detail::IntWrapper<int32_t, 28>;
+using Int29 = detail::IntWrapper<int32_t, 29>;
+using Int30 = detail::IntWrapper<int32_t, 30>;
+using Int31 = detail::IntWrapper<int32_t, 31>;
+using Int33 = detail::IntWrapper<int64_t, 33>;
+using Int34 = detail::IntWrapper<int64_t, 34>;
+using Int35 = detail::IntWrapper<int64_t, 35>;
+using Int36 = detail::IntWrapper<int64_t, 36>;
+using Int37 = detail::IntWrapper<int64_t, 37>;
+using Int38 = detail::IntWrapper<int64_t, 38>;
+using Int39 = detail::IntWrapper<int64_t, 39>;
+using Int40 = detail::IntWrapper<int64_t, 40>;
+using Int41 = detail::IntWrapper<int64_t, 41>;
+using Int42 = detail::IntWrapper<int64_t, 42>;
+using Int43 = detail::IntWrapper<int64_t, 43>;
+using Int44 = detail::IntWrapper<int64_t, 44>;
+using Int45 = detail::IntWrapper<int64_t, 45>;
+using Int46 = detail::IntWrapper<int64_t, 46>;
+using Int47 = detail::IntWrapper<int64_t, 47>;
+using Int48 = detail::IntWrapper<int64_t, 48>;
+using Int49 = detail::IntWrapper<int64_t, 49>;
+using Int50 = detail::IntWrapper<int64_t, 50>;
+using Int51 = detail::IntWrapper<int64_t, 51>;
+using Int52 = detail::IntWrapper<int64_t, 52>;
+using Int53 = detail::IntWrapper<int64_t, 53>;
+using Int54 = detail::IntWrapper<int64_t, 54>;
+using Int55 = detail::IntWrapper<int64_t, 55>;
+using Int56 = detail::IntWrapper<int64_t, 56>;
+using Int57 = detail::IntWrapper<int64_t, 57>;
+using Int58 = detail::IntWrapper<int64_t, 58>;
+using Int59 = detail::IntWrapper<int64_t, 59>;
+using Int60 = detail::IntWrapper<int64_t, 60>;
+using Int61 = detail::IntWrapper<int64_t, 61>;
+using Int62 = detail::IntWrapper<int64_t, 62>;
+using Int63 = detail::IntWrapper<int64_t, 63>;
+
+using UInt1 = detail::IntWrapper<uint8_t, 1>;
+using UInt2 = detail::IntWrapper<uint8_t, 2>;
+using UInt3 = detail::IntWrapper<uint8_t, 3>;
+using UInt4 = detail::IntWrapper<uint8_t, 4>;
+using UInt5 = detail::IntWrapper<uint8_t, 5>;
+using UInt6 = detail::IntWrapper<uint8_t, 6>;
+using UInt7 = detail::IntWrapper<uint8_t, 7>;
+using UInt9 = detail::IntWrapper<uint16_t, 9>;
+using UInt10 = detail::IntWrapper<uint16_t, 10>;
+using UInt11 = detail::IntWrapper<uint16_t, 11>;
+using UInt12 = detail::IntWrapper<uint16_t, 12>;
+using UInt13 = detail::IntWrapper<uint16_t, 13>;
+using UInt14 = detail::IntWrapper<uint16_t, 14>;
+using UInt15 = detail::IntWrapper<uint16_t, 15>;
+using UInt17 = detail::IntWrapper<uint32_t, 17>;
+using UInt18 = detail::IntWrapper<uint32_t, 18>;
+using UInt19 = detail::IntWrapper<uint32_t, 19>;
+using UInt20 = detail::IntWrapper<uint32_t, 20>;
+using UInt21 = detail::IntWrapper<uint32_t, 21>;
+using UInt22 = detail::IntWrapper<uint32_t, 22>;
+using UInt23 = detail::IntWrapper<uint32_t, 23>;
+using UInt24 = detail::IntWrapper<uint32_t, 24>;
+using UInt25 = detail::IntWrapper<uint32_t, 25>;
+using UInt26 = detail::IntWrapper<uint32_t, 26>;
+using UInt27 = detail::IntWrapper<uint32_t, 27>;
+using UInt28 = detail::IntWrapper<uint32_t, 28>;
+using UInt29 = detail::IntWrapper<uint32_t, 29>;
+using UInt30 = detail::IntWrapper<uint32_t, 30>;
+using UInt31 = detail::IntWrapper<uint32_t, 31>;
+using UInt33 = detail::IntWrapper<uint64_t, 33>;
+using UInt34 = detail::IntWrapper<uint64_t, 34>;
+using UInt35 = detail::IntWrapper<uint64_t, 35>;
+using UInt36 = detail::IntWrapper<uint64_t, 36>;
+using UInt37 = detail::IntWrapper<uint64_t, 37>;
+using UInt38 = detail::IntWrapper<uint64_t, 38>;
+using UInt39 = detail::IntWrapper<uint64_t, 39>;
+using UInt40 = detail::IntWrapper<uint64_t, 40>;
+using UInt41 = detail::IntWrapper<uint64_t, 41>;
+using UInt42 = detail::IntWrapper<uint64_t, 42>;
+using UInt43 = detail::IntWrapper<uint64_t, 43>;
+using UInt44 = detail::IntWrapper<uint64_t, 44>;
+using UInt45 = detail::IntWrapper<uint64_t, 45>;
+using UInt46 = detail::IntWrapper<uint64_t, 46>;
+using UInt47 = detail::IntWrapper<uint64_t, 47>;
+using UInt48 = detail::IntWrapper<uint64_t, 48>;
+using UInt49 = detail::IntWrapper<uint64_t, 49>;
+using UInt50 = detail::IntWrapper<uint64_t, 50>;
+using UInt51 = detail::IntWrapper<uint64_t, 51>;
+using UInt52 = detail::IntWrapper<uint64_t, 52>;
+using UInt53 = detail::IntWrapper<uint64_t, 53>;
+using UInt54 = detail::IntWrapper<uint64_t, 54>;
+using UInt55 = detail::IntWrapper<uint64_t, 55>;
+using UInt56 = detail::IntWrapper<uint64_t, 56>;
+using UInt57 = detail::IntWrapper<uint64_t, 57>;
+using UInt58 = detail::IntWrapper<uint64_t, 58>;
+using UInt59 = detail::IntWrapper<uint64_t, 59>;
+using UInt60 = detail::IntWrapper<uint64_t, 60>;
+using UInt61 = detail::IntWrapper<uint64_t, 61>;
+using UInt62 = detail::IntWrapper<uint64_t, 62>;
+using UInt63 = detail::IntWrapper<uint64_t, 63>;
+
+using DynInt8 = detail::DynIntWrapper<int8_t>;
+using DynInt16 = detail::DynIntWrapper<int16_t>;
+using DynInt32 = detail::DynIntWrapper<int32_t>;
+using DynInt64 = detail::DynIntWrapper<int64_t>;
+
+using DynUInt8 = detail::DynIntWrapper<uint8_t>;
+using DynUInt16 = detail::DynIntWrapper<uint16_t>;
+using DynUInt32 = detail::DynIntWrapper<uint32_t>;
+using DynUInt64 = detail::DynIntWrapper<uint64_t>;
+
+using VarInt16 = detail::VarIntWrapper<int16_t, detail::VarIntType::VAR16>;
+using VarInt32 = detail::VarIntWrapper<int32_t, detail::VarIntType::VAR32>;
+using VarInt64 = detail::VarIntWrapper<int64_t, detail::VarIntType::VAR64>;
+using VarInt = detail::VarIntWrapper<int64_t, detail::VarIntType::VAR>;
+
+using VarUInt16 = detail::VarIntWrapper<uint16_t, detail::VarIntType::VAR16>;
+using VarUInt32 = detail::VarIntWrapper<uint32_t, detail::VarIntType::VAR32>;
+using VarUInt64 = detail::VarIntWrapper<uint64_t, detail::VarIntType::VAR64>;
+using VarUInt = detail::VarIntWrapper<uint64_t, detail::VarIntType::VAR>;
+
+using VarSize = detail::VarIntWrapper<uint32_t, detail::VarIntType::VARSIZE>;
+
+using Float16 = detail::FloatWrapper<float, detail::FloatType::FLOAT16>;
+using Float32 = detail::FloatWrapper<float, detail::FloatType::FLOAT32>;
+using Float64 = detail::FloatWrapper<double, detail::FloatType::FLOAT64>;
+
+/** \} */
+
+/**
+ * Allows to append NumericTypeWrapper to CppRuntimeException.
+ *
+ * \param exception Exception to modify.
+ * \param bitBuffer Bit buffer value.
+ *
+ * \return Reference to the exception to allow operator chaining.
+ */
+template <typename VALUE_TYPE>
+CppRuntimeException& operator<<(CppRuntimeException& exception, detail::NumericTypeWrapper<VALUE_TYPE> value)
+{
+    return exception << static_cast<VALUE_TYPE>(value);
+}
+
+} // namespace zserio
 
 #endif // ifndef ZSERIO_TYPES_H_INC
diff --git a/runtime/test/CMakeLists.txt b/runtime/test/CMakeLists.txt
index 24fde0d..9c5cb57 100644
--- a/runtime/test/CMakeLists.txt
+++ b/runtime/test/CMakeLists.txt
@@ -11,6 +11,12 @@ project(ZserioCpp17RuntimeTest)
 include(gtest_utils)
 gtest_add_library("${ZSERIO_CPP17_PROJECT_ROOT}/3rdparty/cpp/googletest")
 
+compiler_set_warnings()
+compiler_set_warnings_as_errors()
+if (SANITIZERS_ENABLED)
+    compiler_set_undefined_sanitizer()
+endif ()
+
 set(ZSERIO_CPP17_RUNTIME_TEST_SRCS
     zserio/BitBufferTest.cpp
     zserio/BitFieldUtilTest.cpp
@@ -26,10 +32,12 @@ set(ZSERIO_CPP17_RUNTIME_TEST_SRCS
     zserio/FileUtilTest.cpp
     zserio/FloatUtilTest.cpp
     zserio/HashCodeUtilTest.cpp
+    zserio/OutOfRangeExceptionTest.cpp
     zserio/SizeConvertUtilTest.cpp
     zserio/SpanTest.cpp
     zserio/StringConvertUtilTest.cpp
     zserio/TrackingAllocator.h
+    zserio/TypesTest.cpp
 )
 
 add_executable(${PROJECT_NAME} ${ZSERIO_CPP17_RUNTIME_TEST_SRCS})
diff --git a/runtime/test/zserio/OutOfRangeExceptionTest.cpp b/runtime/test/zserio/OutOfRangeExceptionTest.cpp
new file mode 100644
index 0000000..759b09f
--- /dev/null
+++ b/runtime/test/zserio/OutOfRangeExceptionTest.cpp
@@ -0,0 +1,17 @@
+#include "gtest/gtest.h"
+#include "zserio/OutOfRangeException.h"
+
+namespace zserio
+{
+
+TEST(OutOfRangeExceptionTest, correctTypeAfterAppend)
+{
+    ASSERT_THROW(
+            {
+                throw OutOfRangeException()
+                        << "Test that appending using operator<< persists the exception type!";
+            },
+            OutOfRangeException);
+}
+
+} // namespace zserio
diff --git a/runtime/test/zserio/TypesTest.cpp b/runtime/test/zserio/TypesTest.cpp
new file mode 100644
index 0000000..7abf91e
--- /dev/null
+++ b/runtime/test/zserio/TypesTest.cpp
@@ -0,0 +1,786 @@
+#include "gtest/gtest.h"
+#include "zserio/Types.h"
+
+namespace zserio
+{
+
+static void testBoolOperators()
+{
+    Bool valueMin = NumericLimits<Bool>::min();
+    Bool valueMax = NumericLimits<Bool>::max();
+
+    // constructor
+    Bool copy(valueMin);
+    Bool copy2 = valueMin;
+    (void)copy;
+    (void)copy2;
+
+    // logical
+    ASSERT_FALSE(!valueMax);
+    ASSERT_FALSE(valueMin && valueMax);
+    ASSERT_TRUE(valueMin || valueMax);
+
+    // comparison
+    ASSERT_FALSE(valueMin == valueMax);
+    ASSERT_TRUE(valueMin != valueMax);
+    ASSERT_TRUE(valueMin < valueMax);
+    ASSERT_FALSE(valueMin > valueMax);
+    ASSERT_TRUE(valueMin <= valueMax);
+    ASSERT_FALSE(valueMin >= valueMax);
+
+    // ternary
+    ASSERT_TRUE(valueMin ? valueMin : valueMax);
+}
+
+template <typename T>
+void testIntOperators(typename T::value_type minValue = NumericLimits<T>::min())
+{
+    T value0;
+    T valueMin = minValue;
+    Int64 valueMax = NumericLimits<Int64>::max();
+
+    // constructor
+    Int64 copy(valueMin);
+    Int64 copy2 = Int64(valueMin);
+    (void)copy;
+    (void)copy2;
+
+    // arithmetic
+    Int64 value = +valueMin;
+    value = -valueMin;
+    value = valueMin + valueMax;
+    value = valueMin - valueMax;
+    value = valueMin * valueMax;
+    if (valueMax != 0) // == 0 for Int1
+    {
+        value = valueMin / valueMax;
+        value = valueMin % valueMax;
+    }
+
+    // increment / decrement
+    ++value;
+    --value;
+    value++;
+    value--;
+
+    // logical
+    ASSERT_FALSE(!valueMin);
+    ASSERT_TRUE(valueMin && valueMax);
+    ASSERT_TRUE(valueMin || valueMax);
+
+    // comparison
+    ASSERT_FALSE(valueMin == valueMax);
+    ASSERT_TRUE(valueMin != valueMax);
+    ASSERT_TRUE(valueMin < valueMax);
+    ASSERT_FALSE(valueMin > valueMax);
+    ASSERT_TRUE(valueMin <= valueMax);
+    ASSERT_FALSE(valueMin >= valueMax);
+
+    // assignment
+    value = Int64(valueMin);
+    value += valueMin;
+    value -= valueMin;
+    value *= valueMin;
+    if (valueMax != 0) // == 0 for Int1
+    {
+        value /= valueMax;
+        value %= valueMax;
+    }
+
+    // ternary
+    value = Int64(valueMin ? valueMin : value0);
+    value = (valueMin ? +(valueMin) : +(valueMax));
+    value = (valueMin ? +(valueMin + value0) : +(valueMax + value0));
+    value = (valueMin ? valueMin + value0 : valueMax + value0);
+    value = (valueMin ? valueMin : valueMax);
+
+    (void)value;
+}
+
+template <typename T>
+void testUIntOperators(typename T::value_type minValue = NumericLimits<T>::min())
+{
+    T value0;
+    T valueMin = minValue;
+    ASSERT_EQ(value0, valueMin);
+    UInt64 valueMax = NumericLimits<UInt64>::max();
+
+    // constructor
+    UInt64 copy(valueMin);
+    UInt64 copy2 = UInt64(valueMin);
+    (void)copy;
+    (void)copy2;
+
+    // arithmetic
+    UInt64 value = +valueMin;
+    value = -valueMax;
+    value = valueMin + valueMax;
+    value = valueMin - valueMax;
+    value = valueMin * valueMax;
+    value = valueMin / valueMax;
+    value = valueMin % valueMax;
+    value = ~valueMin;
+    value = valueMin & valueMax;
+    value = valueMin | valueMax;
+    value = valueMin ^ valueMax;
+    if constexpr (sizeof(T) < 4) // bypass integral promotion
+    {
+        value = valueMax << value0;
+        value = valueMax >> value0;
+    }
+    else
+    {
+        value = valueMin << value0;
+        value = valueMin >> value0;
+    }
+
+    // increment / decrement
+    ++value;
+    --value;
+    value++;
+    value--;
+
+    // logical
+    ASSERT_FALSE(!valueMax);
+    ASSERT_FALSE(valueMin && valueMax);
+    ASSERT_TRUE(valueMin || valueMax);
+
+    // comparison
+    ASSERT_FALSE(valueMin == valueMax);
+    ASSERT_TRUE(valueMin != valueMax);
+    ASSERT_TRUE(valueMin < valueMax);
+    ASSERT_FALSE(valueMin > valueMax);
+    ASSERT_TRUE(valueMin <= valueMax);
+    ASSERT_FALSE(valueMin >= valueMax);
+
+    // assignment
+    value = UInt64(valueMin);
+    value += valueMin;
+    value -= valueMin;
+    value *= valueMin;
+    value /= valueMax;
+    value %= valueMax;
+    value &= valueMin;
+    value |= valueMin;
+    value ^= valueMin;
+    value <<= value0;
+    value >>= value0;
+
+    // ternary
+    value = UInt64(valueMin ? valueMin : value0);
+    value = (valueMin ? +(valueMin) : +(valueMax));
+    value = (valueMin ? +(valueMin + value0) : +(valueMax + value0));
+    value = (valueMin ? valueMin + value0 : valueMax + value0);
+    value = (valueMin ? valueMin : valueMax);
+
+    (void)value;
+}
+
+template <typename T>
+struct FloatTypeHelper
+{
+    using type = Float32;
+};
+
+template <>
+struct FloatTypeHelper<Float64>
+{
+    using type = Float64;
+};
+
+template <typename T>
+void testFloatOperators()
+{
+    using float_wrapper = typename FloatTypeHelper<T>::type;
+
+    T value0;
+    T valueMin = NumericLimits<T>::min();
+    float_wrapper valueMax = NumericLimits<float_wrapper>::max();
+
+    // constructor
+    float_wrapper copy(valueMin);
+    float_wrapper copy2 = float_wrapper(valueMin);
+    (void)copy;
+    (void)copy2;
+
+    // arithmetic
+    float_wrapper value = +valueMin;
+    value = -valueMin;
+    value = valueMin + valueMax;
+    value = valueMin - valueMax;
+    value = valueMin * valueMax;
+    value = valueMin / value0;
+
+    // increment / decrement
+    ++value;
+    --value;
+    value++;
+    value--;
+
+    // comparison
+    ASSERT_TRUE(valueMin < valueMax);
+    ASSERT_FALSE(valueMin > valueMax);
+    ASSERT_TRUE(valueMin <= valueMax);
+    ASSERT_FALSE(valueMin >= valueMax);
+
+    // assignment
+    value = float_wrapper(valueMin);
+    value += valueMin;
+    value -= valueMin;
+    value *= valueMin;
+    value /= valueMax;
+
+    // ternary
+    value = float_wrapper(valueMin < 0 ? valueMin : value0);
+    value = (valueMin < 0 ? +(valueMin) : +(valueMax));
+    value = (valueMin < 0 ? +(valueMin + value0) : +(valueMax + value0));
+    value = (valueMin < 0 ? valueMin + value0 : valueMax + value0);
+    value = (valueMin < 0 ? valueMin : valueMax);
+
+    (void)value;
+}
+
+template <typename T>
+void testSignedStdInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(NumericLimits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
+    static_assert(NumericLimits<T>::max() == std::numeric_limits<value_type>::max(), "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(noexcept(fromCheckedValue<T>(std::declval<value_type>())), "shall be noexcept");
+    static_assert(noexcept(toCheckedValue(std::declval<T>())), "shall be noexcept");
+
+    const T minValue(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), minValue);
+
+    const T maxValue(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), maxValue);
+
+    T checkedMin = fromCheckedValue<T>(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), toCheckedValue(checkedMin));
+
+    T checkedMax = fromCheckedValue<T>(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), toCheckedValue(checkedMax));
+
+    T value;
+    value = static_cast<value_type>(0);
+    ASSERT_EQ(0, value);
+    value = static_cast<value_type>(1);
+    ASSERT_EQ(1, value);
+    value = static_cast<value_type>(-1);
+    ASSERT_EQ(-1, value);
+
+    testIntOperators<T>();
+}
+
+template <typename T>
+void testUnsignedStdInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(NumericLimits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
+    static_assert(NumericLimits<T>::max() == std::numeric_limits<value_type>::max(), "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(noexcept(fromCheckedValue<T>(std::declval<value_type>())), "shall be noexcept");
+    static_assert(noexcept(toCheckedValue(std::declval<T>())), "shall be noexcept");
+
+    const T minValue(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), minValue);
+
+    const T maxValue(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), maxValue);
+
+    T checkedMin = fromCheckedValue<T>(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), toCheckedValue(checkedMin));
+
+    T checkedMax = fromCheckedValue<T>(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), toCheckedValue(checkedMax));
+
+    T value;
+    value = static_cast<value_type>(0);
+    ASSERT_EQ(0, value);
+    value = static_cast<value_type>(1);
+    ASSERT_EQ(1, value);
+    value = static_cast<value_type>(2);
+    ASSERT_EQ(2, value);
+
+    testUIntOperators<T>();
+}
+
+template <typename T, typename T::value_type MIN_VALUE, typename T::value_type MAX_VALUE,
+        bool IS_NOEXCEPT = false>
+void testSignedInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(NumericLimits<T>::min() == MIN_VALUE, "shall be constexpr");
+    static_assert(NumericLimits<T>::max() == MAX_VALUE, "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(
+            IS_NOEXCEPT == noexcept(fromCheckedValue<T>(std::declval<value_type>())), "unexpected noexcept");
+    static_assert(IS_NOEXCEPT == noexcept(toCheckedValue(std::declval<T>())), "unexpected noexcept");
+
+    const T minValue(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), minValue);
+
+    const T maxValue(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), maxValue);
+
+    T checkedMin = fromCheckedValue<T>(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), toCheckedValue(checkedMin));
+
+    T checkedMax = fromCheckedValue<T>(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), toCheckedValue(checkedMax));
+
+    T value;
+    ASSERT_EQ(0, value);
+    value = -1;
+    ASSERT_EQ(-1, value);
+    value = 0;
+    ASSERT_EQ(0, value);
+
+    if constexpr (!IS_NOEXCEPT)
+    {
+        ASSERT_THROW(fromCheckedValue<T>(NumericLimits<T>::min() - 1), OutOfRangeException);
+        ASSERT_THROW(fromCheckedValue<T>(NumericLimits<T>::max() + 1), OutOfRangeException);
+        const T underMin = minValue - 1;
+        ASSERT_THROW(toCheckedValue(underMin), OutOfRangeException);
+        const T overMax = maxValue + 1;
+        ASSERT_THROW(toCheckedValue(overMax), OutOfRangeException);
+    }
+
+    testIntOperators<T>();
+}
+
+template <typename T, typename T::value_type MAX_VALUE, bool IS_NOEXCEPT = false>
+void testUnsignedInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(NumericLimits<T>::min() == 0, "shall be constexpr");
+    static_assert(NumericLimits<T>::max() == MAX_VALUE, "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(
+            IS_NOEXCEPT == noexcept(fromCheckedValue<T>(std::declval<value_type>())), "unexpected noexcept");
+    static_assert(IS_NOEXCEPT == noexcept(toCheckedValue(std::declval<T>())), "unexpected noexcept");
+
+    const T minValue(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), minValue);
+
+    const T maxValue(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), maxValue);
+
+    T checkedMin = fromCheckedValue<T>(NumericLimits<T>::min());
+    ASSERT_EQ(NumericLimits<T>::min(), toCheckedValue(checkedMin));
+
+    T checkedMax = fromCheckedValue<T>(NumericLimits<T>::max());
+    ASSERT_EQ(NumericLimits<T>::max(), toCheckedValue(checkedMax));
+
+    T value;
+    ASSERT_EQ(0, value);
+    value = 1;
+    ASSERT_EQ(1, value);
+    value = NumericLimits<T>::max() - 1;
+    ASSERT_EQ(NumericLimits<T>::max() - 1, value);
+
+    if constexpr (!IS_NOEXCEPT)
+    {
+        ASSERT_THROW(fromCheckedValue<T>(NumericLimits<T>::max() + 1), OutOfRangeException);
+        const T overMax = maxValue + 1;
+        ASSERT_THROW(toCheckedValue(overMax), OutOfRangeException);
+    }
+
+    testUIntOperators<T>();
+}
+
+template <typename T>
+void testSignedDynInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(NumericLimits<T>::min(8) == -128, "shall be constexpr");
+    static_assert(NumericLimits<T>::max(8) == 127, "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(!noexcept(fromCheckedValue<T>(std::declval<value_type>(), std::declval<BitSize>())),
+            "shall not be noexcept");
+    static_assert(
+            !noexcept(toCheckedValue(std::declval<T>(), std::declval<BitSize>())), "shall not be noexcept");
+
+    ASSERT_THROW(fromCheckedValue<T>(0, 0), OutOfRangeException);
+    ASSERT_THROW(fromCheckedValue<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
+
+    for (BitSize numBits = 1; numBits <= sizeof(value_type) * 8; ++numBits)
+    {
+        const T minValue(NumericLimits<T>::min(numBits));
+        ASSERT_EQ(NumericLimits<T>::min(numBits), minValue);
+
+        const T maxValue(NumericLimits<T>::max(numBits));
+        ASSERT_EQ(NumericLimits<T>::max(numBits), maxValue);
+
+        T checkedMin = fromCheckedValue<T>(NumericLimits<T>::min(numBits), numBits);
+        ASSERT_EQ(NumericLimits<T>::min(numBits), toCheckedValue(checkedMin, numBits));
+
+        T checkedMax = fromCheckedValue<T>(NumericLimits<T>::max(numBits), numBits);
+        ASSERT_EQ(NumericLimits<T>::max(numBits), toCheckedValue(checkedMax, numBits));
+
+        T value;
+        ASSERT_EQ(0, value);
+        value = -1;
+        ASSERT_EQ(-1, value);
+        value = 0;
+        ASSERT_EQ(0, value);
+
+        if (numBits < sizeof(value_type) * 8)
+        {
+            ASSERT_THROW(fromCheckedValue<T>(NumericLimits<T>::min(numBits) - 1, numBits), OutOfRangeException)
+                    << numBits;
+            ASSERT_THROW(fromCheckedValue<T>(NumericLimits<T>::max(numBits) + 1, numBits), OutOfRangeException);
+            const T underMin = minValue - 1;
+            ASSERT_THROW(toCheckedValue(underMin, numBits), OutOfRangeException);
+            const T overMax = maxValue + 1;
+            ASSERT_THROW(toCheckedValue(overMax, numBits), OutOfRangeException);
+        }
+
+        testIntOperators<T>(NumericLimits<T>::min(numBits));
+    }
+}
+
+template <typename T>
+void testUnsignedDynInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(NumericLimits<T>::min(8) == 0, "shall be constexpr");
+    static_assert(NumericLimits<T>::max(8) == 255, "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(!noexcept(fromCheckedValue<T>(std::declval<value_type>(), std::declval<BitSize>())),
+            "shall not be noexcept");
+    static_assert(
+            !noexcept(toCheckedValue(std::declval<T>(), std::declval<BitSize>())), "shall not be noexcept");
+
+    ASSERT_THROW(fromCheckedValue<T>(0, 0), OutOfRangeException);
+    ASSERT_THROW(fromCheckedValue<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
+
+    for (BitSize numBits = 1; numBits <= sizeof(value_type) * 8; ++numBits)
+    {
+        const T minValue(NumericLimits<T>::min(numBits));
+        ASSERT_EQ(NumericLimits<T>::min(numBits), minValue);
+
+        const T maxValue(NumericLimits<T>::max(numBits));
+        ASSERT_EQ(NumericLimits<T>::max(numBits), maxValue);
+
+        T checkedMin = fromCheckedValue<T>(NumericLimits<T>::min(numBits), numBits);
+        ASSERT_EQ(NumericLimits<T>::min(numBits), toCheckedValue(checkedMin, numBits));
+
+        T checkedMax = fromCheckedValue<T>(NumericLimits<T>::max(numBits), numBits);
+        ASSERT_EQ(NumericLimits<T>::max(numBits), toCheckedValue(checkedMax, numBits));
+
+        T value;
+        ASSERT_EQ(0, value);
+        value = 1;
+        ASSERT_EQ(1, value);
+        value = NumericLimits<T>::max(numBits) - 1;
+        ASSERT_EQ(NumericLimits<T>::max(numBits) - 1, value);
+
+        if (numBits < sizeof(value_type) * 8)
+        {
+            ASSERT_THROW(fromCheckedValue<T>(NumericLimits<T>::max(numBits) + 1, numBits), OutOfRangeException);
+            const T overMax = maxValue + 1;
+            ASSERT_THROW(toCheckedValue(overMax, numBits), OutOfRangeException);
+        }
+
+        testUIntOperators<T>(NumericLimits<T>::min(numBits));
+    }
+}
+
+template <typename T>
+constexpr void testFloat()
+{
+    using value_type = typename T::value_type;
+
+    if constexpr (std::is_same_v<T, Float16>)
+    {
+        // cannot compare floating point numbers directly
+        static_assert(NumericLimits<T>::min() > 0.F, "shall be constexpr");
+        static_assert(NumericLimits<T>::max() > 0.F, "shall be constexpr");
+
+        ASSERT_FLOAT_EQ(NumericLimits<T>::min(), 6.103515625e-05F);
+        ASSERT_FLOAT_EQ(NumericLimits<T>::max(), 65504.F);
+    }
+    else
+    {
+        // cannot compare floating point numbers directly
+        static_assert(NumericLimits<T>::min() > static_cast<value_type>(0.), "shall be constexpr");
+        static_assert(NumericLimits<T>::max() > static_cast<value_type>(0.), "shall be constexpr");
+
+        ASSERT_DOUBLE_EQ(NumericLimits<T>::min(), std::numeric_limits<value_type>::min());
+    }
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(noexcept(fromCheckedValue<T>(std::declval<value_type>())), "shall be noexcept");
+    static_assert(noexcept(toCheckedValue(std::declval<T>())), "shall be noexcept");
+
+    const T minValue(NumericLimits<T>::min());
+    ASSERT_DOUBLE_EQ(NumericLimits<T>::min(), minValue);
+
+    const T maxValue(NumericLimits<T>::max());
+    ASSERT_DOUBLE_EQ(NumericLimits<T>::max(), maxValue);
+
+    T checkedMin = fromCheckedValue<T>(NumericLimits<T>::min());
+    ASSERT_DOUBLE_EQ(NumericLimits<T>::min(), toCheckedValue(checkedMin));
+
+    T checkedMax = fromCheckedValue<T>(NumericLimits<T>::max());
+    ASSERT_DOUBLE_EQ(NumericLimits<T>::max(), toCheckedValue(checkedMax));
+
+    T value;
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(0.0), value);
+    value = static_cast<value_type>(1.0);
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(1.0), value);
+    value = static_cast<value_type>(0.0);
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(0.0), value);
+
+    T checked_value = fromCheckedValue<T>(static_cast<value_type>(1.0));
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(1.0), toCheckedValue(checked_value));
+
+    testFloatOperators<T>();
+}
+
+TEST(TypesTest, boolType)
+{
+    static_assert(std::is_nothrow_constructible_v<Bool, bool>, "shall be noexcept");
+    static_assert(noexcept(fromCheckedValue<Bool>(std::declval<bool>())), "shall be noexcept");
+    static_assert(noexcept(toCheckedValue(std::declval<Bool>())), "shall be noexcept");
+
+    const Bool minValue(NumericLimits<Bool>::min());
+    ASSERT_EQ(NumericLimits<Bool>::min(), minValue);
+
+    const Bool maxValue(NumericLimits<Bool>::max());
+    ASSERT_EQ(NumericLimits<Bool>::max(), maxValue);
+
+    Bool checkedMin = fromCheckedValue<Bool>(NumericLimits<Bool>::min());
+    ASSERT_EQ(NumericLimits<Bool>::min(), toCheckedValue(checkedMin));
+
+    Bool checkedMax = fromCheckedValue<Bool>(NumericLimits<Bool>::max());
+    ASSERT_EQ(NumericLimits<Bool>::max(), toCheckedValue(checkedMax));
+
+    Bool value;
+    ASSERT_EQ(false, value);
+    value = true;
+    ASSERT_EQ(true, value);
+    value = false;
+    ASSERT_EQ(false, value);
+
+    testBoolOperators();
+}
+
+TEST(TypesTest, signedStdIntTypes)
+{
+    testSignedStdInt<Int8>();
+    testSignedStdInt<Int16>();
+    testSignedStdInt<Int32>();
+    testSignedStdInt<Int64>();
+}
+
+TEST(TypesTest, unsignedStdIntTypes)
+{
+    testUnsignedStdInt<UInt8>();
+    testUnsignedStdInt<UInt16>();
+    testUnsignedStdInt<UInt32>();
+    testUnsignedStdInt<UInt64>();
+}
+
+TEST(TypesTest, signedBitFieldTypes)
+{
+    testSignedInt<Int1, -1, 0>();
+    testSignedInt<Int2, -2, 1>();
+    testSignedInt<Int3, -4, 3>();
+    testSignedInt<Int4, -8, 7>();
+    testSignedInt<Int5, -16, 15>();
+    testSignedInt<Int6, -32, 31>();
+    testSignedInt<Int7, -64, 63>();
+    testSignedInt<Int9, -256, 255>();
+    testSignedInt<Int10, -512, 511>();
+    testSignedInt<Int11, -1024, 1023>();
+    testSignedInt<Int12, -2048, 2047>();
+    testSignedInt<Int13, -4096, 4095>();
+    testSignedInt<Int14, -8192, 8191>();
+    testSignedInt<Int15, -16384, 16383>();
+    testSignedInt<Int17, -65536, 65535>();
+    testSignedInt<Int18, -131072, 131071>();
+    testSignedInt<Int19, -262144, 262143>();
+    testSignedInt<Int20, -524288, 524287>();
+    testSignedInt<Int21, -1048576, 1048575>();
+    testSignedInt<Int22, -2097152, 2097151>();
+    testSignedInt<Int23, -4194304, 4194303>();
+    testSignedInt<Int24, -8388608, 8388607>();
+    testSignedInt<Int25, -16777216, 16777215>();
+    testSignedInt<Int26, -33554432, 33554431>();
+    testSignedInt<Int27, -67108864, 67108863>();
+    testSignedInt<Int28, -134217728, 134217727>();
+    testSignedInt<Int29, -268435456, 268435455>();
+    testSignedInt<Int30, -536870912, 536870911>();
+    testSignedInt<Int31, -1073741824, 1073741823>();
+    testSignedInt<Int33, -4294967296LL, 4294967295LL>();
+    testSignedInt<Int34, -8589934592LL, 8589934591LL>();
+    testSignedInt<Int35, -17179869184LL, 17179869183LL>();
+    testSignedInt<Int36, -34359738368LL, 34359738367LL>();
+    testSignedInt<Int37, -68719476736LL, 68719476735LL>();
+    testSignedInt<Int38, -137438953472LL, 137438953471LL>();
+    testSignedInt<Int39, -274877906944LL, 274877906943LL>();
+    testSignedInt<Int40, -549755813888LL, 549755813887LL>();
+    testSignedInt<Int41, -1099511627776LL, 1099511627775LL>();
+    testSignedInt<Int42, -2199023255552LL, 2199023255551LL>();
+    testSignedInt<Int43, -4398046511104LL, 4398046511103LL>();
+    testSignedInt<Int44, -8796093022208LL, 8796093022207LL>();
+    testSignedInt<Int45, -17592186044416LL, 17592186044415LL>();
+    testSignedInt<Int46, -35184372088832LL, 35184372088831LL>();
+    testSignedInt<Int47, -70368744177664LL, 70368744177663LL>();
+    testSignedInt<Int48, -140737488355328LL, 140737488355327LL>();
+    testSignedInt<Int49, -281474976710656LL, 281474976710655LL>();
+    testSignedInt<Int50, -562949953421312LL, 562949953421311LL>();
+    testSignedInt<Int51, -1125899906842624LL, 1125899906842623LL>();
+    testSignedInt<Int52, -2251799813685248LL, 2251799813685247LL>();
+    testSignedInt<Int53, -4503599627370496LL, 4503599627370495LL>();
+    testSignedInt<Int54, -9007199254740992LL, 9007199254740991LL>();
+    testSignedInt<Int55, -18014398509481984LL, 18014398509481983LL>();
+    testSignedInt<Int56, -36028797018963968LL, 36028797018963967LL>();
+    testSignedInt<Int57, -72057594037927936LL, 72057594037927935LL>();
+    testSignedInt<Int58, -144115188075855872LL, 144115188075855871LL>();
+    testSignedInt<Int59, -288230376151711744LL, 288230376151711743LL>();
+    testSignedInt<Int60, -576460752303423488LL, 576460752303423487LL>();
+    testSignedInt<Int61, -1152921504606846976LL, 1152921504606846975LL>();
+    testSignedInt<Int62, -2305843009213693952LL, 2305843009213693951LL>();
+    testSignedInt<Int63, -4611686018427387904LL, 4611686018427387903LL>();
+}
+
+TEST(TypesTest, unsignedBitFieldTypes)
+{
+    testUnsignedInt<UInt1, 1ULL>();
+    testUnsignedInt<UInt2, 3ULL>();
+    testUnsignedInt<UInt3, 7ULL>();
+    testUnsignedInt<UInt4, 15ULL>();
+    testUnsignedInt<UInt5, 31ULL>();
+    testUnsignedInt<UInt6, 63ULL>();
+    testUnsignedInt<UInt7, 127ULL>();
+    testUnsignedInt<UInt9, 511ULL>();
+    testUnsignedInt<UInt10, 1023ULL>();
+    testUnsignedInt<UInt11, 2047ULL>();
+    testUnsignedInt<UInt12, 4095ULL>();
+    testUnsignedInt<UInt13, 8191ULL>();
+    testUnsignedInt<UInt14, 16383ULL>();
+    testUnsignedInt<UInt15, 32767ULL>();
+    testUnsignedInt<UInt17, 131071ULL>();
+    testUnsignedInt<UInt18, 262143ULL>();
+    testUnsignedInt<UInt19, 524287ULL>();
+    testUnsignedInt<UInt20, 1048575ULL>();
+    testUnsignedInt<UInt21, 2097151ULL>();
+    testUnsignedInt<UInt22, 4194303ULL>();
+    testUnsignedInt<UInt23, 8388607ULL>();
+    testUnsignedInt<UInt24, 16777215ULL>();
+    testUnsignedInt<UInt25, 33554431ULL>();
+    testUnsignedInt<UInt26, 67108863ULL>();
+    testUnsignedInt<UInt27, 134217727ULL>();
+    testUnsignedInt<UInt28, 268435455ULL>();
+    testUnsignedInt<UInt29, 536870911ULL>();
+    testUnsignedInt<UInt30, 1073741823ULL>();
+    testUnsignedInt<UInt31, 2147483647ULL>();
+    testUnsignedInt<UInt33, 8589934591ULL>();
+    testUnsignedInt<UInt34, 17179869183ULL>();
+    testUnsignedInt<UInt35, 34359738367ULL>();
+    testUnsignedInt<UInt36, 68719476735ULL>();
+    testUnsignedInt<UInt37, 137438953471ULL>();
+    testUnsignedInt<UInt38, 274877906943ULL>();
+    testUnsignedInt<UInt39, 549755813887ULL>();
+    testUnsignedInt<UInt40, 1099511627775ULL>();
+    testUnsignedInt<UInt41, 2199023255551ULL>();
+    testUnsignedInt<UInt42, 4398046511103ULL>();
+    testUnsignedInt<UInt43, 8796093022207ULL>();
+    testUnsignedInt<UInt44, 17592186044415ULL>();
+    testUnsignedInt<UInt45, 35184372088831ULL>();
+    testUnsignedInt<UInt46, 70368744177663ULL>();
+    testUnsignedInt<UInt47, 140737488355327ULL>();
+    testUnsignedInt<UInt48, 281474976710655ULL>();
+    testUnsignedInt<UInt49, 562949953421311ULL>();
+    testUnsignedInt<UInt50, 1125899906842623ULL>();
+    testUnsignedInt<UInt51, 2251799813685247ULL>();
+    testUnsignedInt<UInt52, 4503599627370495ULL>();
+    testUnsignedInt<UInt53, 9007199254740991ULL>();
+    testUnsignedInt<UInt54, 18014398509481983ULL>();
+    testUnsignedInt<UInt55, 36028797018963967ULL>();
+    testUnsignedInt<UInt56, 72057594037927935ULL>();
+    testUnsignedInt<UInt57, 144115188075855871ULL>();
+    testUnsignedInt<UInt58, 288230376151711743ULL>();
+    testUnsignedInt<UInt59, 576460752303423487ULL>();
+    testUnsignedInt<UInt60, 1152921504606846975ULL>();
+    testUnsignedInt<UInt61, 2305843009213693951ULL>();
+    testUnsignedInt<UInt62, 4611686018427387903ULL>();
+    testUnsignedInt<UInt63, 9223372036854775807ULL>();
+}
+
+TEST(TypesTest, signedDynIntTypes)
+{
+    testSignedDynInt<DynInt8>();
+    testSignedDynInt<DynInt16>();
+    testSignedDynInt<DynInt32>();
+    testSignedDynInt<DynInt64>();
+}
+
+TEST(TypesTest, unsignedDynIntTypes)
+{
+    testUnsignedDynInt<DynUInt8>();
+    testUnsignedDynInt<DynUInt16>();
+    testUnsignedDynInt<DynUInt32>();
+    testUnsignedDynInt<DynUInt64>();
+}
+
+TEST(TypesTest, signedVarIntTypes)
+{
+    testSignedInt<VarInt16, -16383, 16383>();
+    testSignedInt<VarInt32, -268435455, 268435455>();
+    testSignedInt<VarInt64, -72057594037927935LL, 72057594037927935LL>();
+    testSignedInt<VarInt, INT64_MIN, INT64_MAX, true>();
+}
+
+TEST(TypesTest, unsignedVarIntTypes)
+{
+    testUnsignedInt<VarUInt16, 32767>();
+    testUnsignedInt<VarUInt32, 536870911>();
+    testUnsignedInt<VarUInt64, 144115188075855871ULL>();
+    testUnsignedInt<VarUInt, UINT64_MAX, true>();
+    testUnsignedInt<VarSize, 2147483647>();
+}
+
+TEST(TypesTest, floatTypes)
+{
+    testFloat<Float16>();
+    testFloat<Float32>();
+    testFloat<Float64>();
+}
+
+TEST(TypesTest, typeCast)
+{
+    {
+        Int32 i32;
+        Int16 i16 = typeCast<Int16>(i32);
+        i32 = Int32(i16);
+    }
+    {
+        Int16 i16;
+        DynInt8 dynI8 = typeCast<DynInt8>(i16);
+        i16 = Int16(dynI8);
+    }
+    {
+        Float16 f16;
+        Int16 i16 = typeCast<Int16>(f16);
+        f16 = typeCast<Float16>(i16);
+    }
+}
+
+} // namespace zserio