diff --git a/runtime/src/zserio/Types.h b/runtime/src/zserio/Types.h
index e93a2b3..a2c8e67 100644
--- a/runtime/src/zserio/Types.h
+++ b/runtime/src/zserio/Types.h
@@ -13,233 +13,506 @@ namespace zserio
 /** Typedef for bit size type used in Zserio. */
 using BitSize = unsigned int;
 
+template <typename T>
+struct Limits
+{};
+
 namespace detail
 {
 
-template <typename VALUE_TYPE, BitSize BIT_SIZE = 8 * sizeof(VALUE_TYPE)>
-class IntegralType
+template <typename VALUE_TYPE>
+class TypeWrapper
 {
+public:
+    using value_type = VALUE_TYPE;
+
+    constexpr explicit TypeWrapper() noexcept :
+            m_value()
+    {}
+
+    constexpr TypeWrapper(value_type value) noexcept :
+            m_value(value)
+    {}
+
+    constexpr operator value_type() const
+    {
+        return m_value;
+    }
+
 private:
-    static_assert((BIT_SIZE + 7) / 8 <= sizeof(VALUE_TYPE), "BitSize doesn't fit the the VALUE_TYPE!");
+    value_type m_value;
+};
 
-    static constexpr bool IS_FULL_STD_INTEGRAL_TYPE = sizeof(VALUE_TYPE) * 8 == BIT_SIZE &&
-            (BIT_SIZE == 8 || BIT_SIZE == 16 || BIT_SIZE == 32 || BIT_SIZE == 64);
+template <typename VALUE_TYPE, BitSize BIT_SIZE = 8 * sizeof(VALUE_TYPE)>
+class IntWrapper : public TypeWrapper<VALUE_TYPE>
+{
+private:
+    static_assert((BIT_SIZE + 7) / 8 <= sizeof(VALUE_TYPE), "BitSize doesn't fit to the VALUE_TYPE!");
 
 public:
     using value_type = VALUE_TYPE;
-    static constexpr value_type MIN_VALUE = []() {
-        if constexpr (IS_FULL_STD_INTEGRAL_TYPE)
+
+    using TypeWrapper<VALUE_TYPE>::TypeWrapper;
+};
+
+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 TypeWrapper<VALUE_TYPE>
+{
+    static_assert(
+            VAR_TYPE != VarIntType::VARSIZE || std::is_unsigned_v<VALUE_TYPE>, "VARSIZE must be unsigned!");
+
+public:
+    using TypeWrapper<VALUE_TYPE>::TypeWrapper;
+};
+
+template <typename TYPE_WRAPPER>
+struct needs_range_check
+{};
+
+template <typename TYPE_WRAPPER>
+inline constexpr bool needs_range_check_v = needs_range_check<TYPE_WRAPPER>::value;
+
+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 TYPE_WRAPPER>
+struct RangeChecker
+{
+    static constexpr void check(typename TYPE_WRAPPER::value_type value) noexcept(
+            !detail::needs_range_check_v<TYPE_WRAPPER>)
+    {
+        if constexpr (std::is_signed_v<typename TYPE_WRAPPER::value_type>)
         {
-            return std::numeric_limits<value_type>::min();
+            if (value < Limits<TYPE_WRAPPER>::min() || value > Limits<TYPE_WRAPPER>::max())
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of range '<" << Limits<TYPE_WRAPPER>::min() << ", "
+                        << Limits<TYPE_WRAPPER>::max() << ">'!";
+            }
         }
-        else if constexpr (std::is_signed_v<value_type>)
+        else
         {
-            return -static_cast<value_type>(1ULL << (BIT_SIZE - 1U));
+            if (value > Limits<TYPE_WRAPPER>::max())
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of bounds '" << Limits<TYPE_WRAPPER>::max() << "'!";
+            }
+        }
+    }
+};
+
+template <typename VALUE_TYPE>
+struct RangeChecker<DynIntWrapper<VALUE_TYPE>>
+{
+    static constexpr void check(VALUE_TYPE value, 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 << ">'!";
+        }
+
+        if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            if (value < Limits<DynIntWrapper<VALUE_TYPE>>::min(numBits) ||
+                    value > Limits<DynIntWrapper<VALUE_TYPE>>::max(numBits))
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of range '<" << Limits<DynIntWrapper<VALUE_TYPE>>::min(numBits)
+                        << ", " << Limits<DynIntWrapper<VALUE_TYPE>>::max(numBits) << ">'!";
+            }
         }
         else
         {
-            return value_type();
+            if (value > Limits<DynIntWrapper<VALUE_TYPE>>::max(numBits))
+            {
+                throw OutOfRangeException("Value '")
+                        << value << "' out of bounds '" << Limits<DynIntWrapper<VALUE_TYPE>>::max(numBits)
+                        << "'!";
+            }
         }
-    }();
+    }
+};
 
-    static constexpr value_type MAX_VALUE = []() {
-        if constexpr (IS_FULL_STD_INTEGRAL_TYPE)
+} // namespace detail
+
+template <typename VALUE_TYPE, BitSize BIT_SIZE>
+struct Limits<detail::IntWrapper<VALUE_TYPE, BIT_SIZE>>
+{
+    static constexpr VALUE_TYPE min() noexcept
+    {
+        if constexpr (!detail::needs_range_check_v<detail::IntWrapper<VALUE_TYPE, BIT_SIZE>>)
         {
-            return std::numeric_limits<value_type>::max();
+            return std::numeric_limits<VALUE_TYPE>::min();
         }
-        else if constexpr (std::is_signed_v<value_type>)
+        else if constexpr (std::is_signed_v<VALUE_TYPE>)
         {
-            return static_cast<value_type>((1ULL << (BIT_SIZE - 1U)) - 1U);
+            return -static_cast<VALUE_TYPE>(1ULL << (BIT_SIZE - 1U));
         }
         else
         {
-            return static_cast<value_type>((1ULL << BIT_SIZE) - 1U);
+            return 0;
         }
-    }();
+    }
 
-    constexpr explicit IntegralType() noexcept :
-            m_value()
-    {}
+    static constexpr VALUE_TYPE 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);
+        }
+    }
+};
 
-    constexpr IntegralType(value_type value) noexcept(IS_FULL_STD_INTEGRAL_TYPE) :
-            m_value(withRangeCheck(value))
-    {}
+template <typename VALUE_TYPE, detail::VarIntType VAR_TYPE>
+struct Limits<detail::VarIntWrapper<VALUE_TYPE, VAR_TYPE>>
+{
+    static constexpr VALUE_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;
+        }
+    }
 
-    constexpr value_type get() const
+    static constexpr VALUE_TYPE max() noexcept
     {
-        return m_value;
+        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;
+        }
     }
 
-    void set(value_type value) noexcept(IS_FULL_STD_INTEGRAL_TYPE)
+private:
+    static constexpr uint64_t FIRST_BYTE_BITS = std::is_signed_v<VALUE_TYPE> ? 6 : 7;
+};
+
+template <typename VALUE_TYPE>
+struct Limits<detail::DynIntWrapper<VALUE_TYPE>>
+{
+    static constexpr VALUE_TYPE min(BitSize numBits)
     {
-        m_value = withRangeCheck(value);
+        if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            return minSignedValue(numBits);
+        }
+        else
+        {
+            return 0;
+        }
     }
 
-    constexpr operator value_type() const
+    static constexpr VALUE_TYPE max(BitSize numBits)
     {
-        return m_value;
+        if constexpr (std::is_signed_v<VALUE_TYPE>)
+        {
+            return maxSignedValue(numBits);
+        }
+        else
+        {
+            return maxUnsignedValue(numBits);
+        }
     }
 
 private:
-    value_type withRangeCheck(value_type value) const noexcept(IS_FULL_STD_INTEGRAL_TYPE)
+    static constexpr VALUE_TYPE minSignedValue(BitSize numBits)
     {
-        if constexpr (!IS_FULL_STD_INTEGRAL_TYPE)
+        if constexpr (std::is_same_v<VALUE_TYPE, int64_t>)
         {
-            if constexpr (std::is_signed_v<value_type>)
+            if (numBits == 64)
             {
-                if (value < MIN_VALUE || value > MAX_VALUE)
-                {
-                    throw OutOfRangeException();
-                }
+                return INT64_MIN;
             }
-            else
+        }
+
+        return -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)
             {
-                if (value > MAX_VALUE)
-                {
-                    throw OutOfRangeException();
-                }
+                return INT64_MAX;
             }
         }
 
-        return value;
+        return static_cast<VALUE_TYPE>((1ULL << (numBits - 1U)) - 1U);
     }
 
-    value_type m_value;
+    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);
+    }
 };
 
-} // namespace detail
+template <typename TYPE_WRAPPER>
+constexpr TYPE_WRAPPER checked_cast(typename TYPE_WRAPPER::value_type value) noexcept(
+        !detail::needs_range_check_v<TYPE_WRAPPER>)
+{
+    if constexpr (detail::needs_range_check_v<TYPE_WRAPPER>)
+    {
+        detail::RangeChecker<TYPE_WRAPPER>::check(value);
+    }
+
+    return TYPE_WRAPPER(value);
+}
+
+template <typename TYPE_WRAPPER>
+constexpr typename TYPE_WRAPPER::value_type checked_cast(TYPE_WRAPPER wrapper) noexcept(
+        !detail::needs_range_check_v<TYPE_WRAPPER>)
+{
+    if constexpr (detail::needs_range_check_v<TYPE_WRAPPER>)
+    {
+        detail::RangeChecker<TYPE_WRAPPER>::check(wrapper);
+    }
+
+    return wrapper;
+}
+
+template <typename TYPE_WRAPPER>
+constexpr TYPE_WRAPPER checked_cast(typename TYPE_WRAPPER::value_type value, BitSize numBits)
+{
+    detail::RangeChecker<TYPE_WRAPPER>::check(value, numBits);
+
+    return TYPE_WRAPPER(value);
+}
+
+template <typename TYPE_WRAPPER>
+constexpr typename TYPE_WRAPPER::value_type checked_cast(TYPE_WRAPPER wrapper, BitSize numBits)
+{
+    detail::RangeChecker<TYPE_WRAPPER>::check(wrapper, numBits);
+
+    return wrapper;
+}
+
+using Int8 = detail::IntWrapper<int8_t>;
+using Int16 = detail::IntWrapper<int16_t>;
+using Int32 = detail::IntWrapper<int32_t>;
+using Int64 = detail::IntWrapper<int64_t>;
+
+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 Int8 = detail::IntegralType<int8_t>;
-using Int16 = detail::IntegralType<int16_t>;
-using Int32 = detail::IntegralType<int32_t>;
-using Int64 = detail::IntegralType<int64_t>;
-
-using UInt8 = detail::IntegralType<uint8_t>;
-using UInt16 = detail::IntegralType<uint16_t>;
-using UInt32 = detail::IntegralType<uint32_t>;
-using UInt64 = detail::IntegralType<uint64_t>;
-
-using Int1 = detail::IntegralType<int8_t, 1>;
-using Int2 = detail::IntegralType<int8_t, 2>;
-using Int3 = detail::IntegralType<int8_t, 3>;
-using Int4 = detail::IntegralType<int8_t, 4>;
-using Int5 = detail::IntegralType<int8_t, 5>;
-using Int6 = detail::IntegralType<int8_t, 6>;
-using Int7 = detail::IntegralType<int8_t, 7>;
-using Int9 = detail::IntegralType<int16_t, 9>;
-using Int10 = detail::IntegralType<int16_t, 10>;
-using Int11 = detail::IntegralType<int16_t, 11>;
-using Int12 = detail::IntegralType<int16_t, 12>;
-using Int13 = detail::IntegralType<int16_t, 13>;
-using Int14 = detail::IntegralType<int16_t, 14>;
-using Int15 = detail::IntegralType<int16_t, 15>;
-using Int17 = detail::IntegralType<int32_t, 17>;
-using Int18 = detail::IntegralType<int32_t, 18>;
-using Int19 = detail::IntegralType<int32_t, 19>;
-using Int20 = detail::IntegralType<int32_t, 20>;
-using Int21 = detail::IntegralType<int32_t, 21>;
-using Int22 = detail::IntegralType<int32_t, 22>;
-using Int23 = detail::IntegralType<int32_t, 23>;
-using Int24 = detail::IntegralType<int32_t, 24>;
-using Int25 = detail::IntegralType<int32_t, 25>;
-using Int26 = detail::IntegralType<int32_t, 26>;
-using Int27 = detail::IntegralType<int32_t, 27>;
-using Int28 = detail::IntegralType<int32_t, 28>;
-using Int29 = detail::IntegralType<int32_t, 29>;
-using Int30 = detail::IntegralType<int32_t, 30>;
-using Int31 = detail::IntegralType<int32_t, 31>;
-using Int33 = detail::IntegralType<int64_t, 33>;
-using Int34 = detail::IntegralType<int64_t, 34>;
-using Int35 = detail::IntegralType<int64_t, 35>;
-using Int36 = detail::IntegralType<int64_t, 36>;
-using Int37 = detail::IntegralType<int64_t, 37>;
-using Int38 = detail::IntegralType<int64_t, 38>;
-using Int39 = detail::IntegralType<int64_t, 39>;
-using Int40 = detail::IntegralType<int64_t, 40>;
-using Int41 = detail::IntegralType<int64_t, 41>;
-using Int42 = detail::IntegralType<int64_t, 42>;
-using Int43 = detail::IntegralType<int64_t, 43>;
-using Int44 = detail::IntegralType<int64_t, 44>;
-using Int45 = detail::IntegralType<int64_t, 45>;
-using Int46 = detail::IntegralType<int64_t, 46>;
-using Int47 = detail::IntegralType<int64_t, 47>;
-using Int48 = detail::IntegralType<int64_t, 48>;
-using Int49 = detail::IntegralType<int64_t, 49>;
-using Int50 = detail::IntegralType<int64_t, 50>;
-using Int51 = detail::IntegralType<int64_t, 51>;
-using Int52 = detail::IntegralType<int64_t, 52>;
-using Int53 = detail::IntegralType<int64_t, 53>;
-using Int54 = detail::IntegralType<int64_t, 54>;
-using Int55 = detail::IntegralType<int64_t, 55>;
-using Int56 = detail::IntegralType<int64_t, 56>;
-using Int57 = detail::IntegralType<int64_t, 57>;
-using Int58 = detail::IntegralType<int64_t, 58>;
-using Int59 = detail::IntegralType<int64_t, 59>;
-using Int60 = detail::IntegralType<int64_t, 60>;
-using Int61 = detail::IntegralType<int64_t, 61>;
-using Int62 = detail::IntegralType<int64_t, 62>;
-using Int63 = detail::IntegralType<int64_t, 63>;
-
-using UInt1 = detail::IntegralType<uint8_t, 1>;
-using UInt2 = detail::IntegralType<uint8_t, 2>;
-using UInt3 = detail::IntegralType<uint8_t, 3>;
-using UInt4 = detail::IntegralType<uint8_t, 4>;
-using UInt5 = detail::IntegralType<uint8_t, 5>;
-using UInt6 = detail::IntegralType<uint8_t, 6>;
-using UInt7 = detail::IntegralType<uint8_t, 7>;
-using UInt9 = detail::IntegralType<uint16_t, 9>;
-using UInt10 = detail::IntegralType<uint16_t, 10>;
-using UInt11 = detail::IntegralType<uint16_t, 11>;
-using UInt12 = detail::IntegralType<uint16_t, 12>;
-using UInt13 = detail::IntegralType<uint16_t, 13>;
-using UInt14 = detail::IntegralType<uint16_t, 14>;
-using UInt15 = detail::IntegralType<uint16_t, 15>;
-using UInt17 = detail::IntegralType<uint32_t, 17>;
-using UInt18 = detail::IntegralType<uint32_t, 18>;
-using UInt19 = detail::IntegralType<uint32_t, 19>;
-using UInt20 = detail::IntegralType<uint32_t, 20>;
-using UInt21 = detail::IntegralType<uint32_t, 21>;
-using UInt22 = detail::IntegralType<uint32_t, 22>;
-using UInt23 = detail::IntegralType<uint32_t, 23>;
-using UInt24 = detail::IntegralType<uint32_t, 24>;
-using UInt25 = detail::IntegralType<uint32_t, 25>;
-using UInt26 = detail::IntegralType<uint32_t, 26>;
-using UInt27 = detail::IntegralType<uint32_t, 27>;
-using UInt28 = detail::IntegralType<uint32_t, 28>;
-using UInt29 = detail::IntegralType<uint32_t, 29>;
-using UInt30 = detail::IntegralType<uint32_t, 30>;
-using UInt31 = detail::IntegralType<uint32_t, 31>;
-using UInt33 = detail::IntegralType<uint64_t, 33>;
-using UInt34 = detail::IntegralType<uint64_t, 34>;
-using UInt35 = detail::IntegralType<uint64_t, 35>;
-using UInt36 = detail::IntegralType<uint64_t, 36>;
-using UInt37 = detail::IntegralType<uint64_t, 37>;
-using UInt38 = detail::IntegralType<uint64_t, 38>;
-using UInt39 = detail::IntegralType<uint64_t, 39>;
-using UInt40 = detail::IntegralType<uint64_t, 40>;
-using UInt41 = detail::IntegralType<uint64_t, 41>;
-using UInt42 = detail::IntegralType<uint64_t, 42>;
-using UInt43 = detail::IntegralType<uint64_t, 43>;
-using UInt44 = detail::IntegralType<uint64_t, 44>;
-using UInt45 = detail::IntegralType<uint64_t, 45>;
-using UInt46 = detail::IntegralType<uint64_t, 46>;
-using UInt47 = detail::IntegralType<uint64_t, 47>;
-using UInt48 = detail::IntegralType<uint64_t, 48>;
-using UInt49 = detail::IntegralType<uint64_t, 49>;
-using UInt50 = detail::IntegralType<uint64_t, 50>;
-using UInt51 = detail::IntegralType<uint64_t, 51>;
-using UInt52 = detail::IntegralType<uint64_t, 52>;
-using UInt53 = detail::IntegralType<uint64_t, 53>;
-using UInt54 = detail::IntegralType<uint64_t, 54>;
-using UInt55 = detail::IntegralType<uint64_t, 55>;
-using UInt56 = detail::IntegralType<uint64_t, 56>;
-using UInt57 = detail::IntegralType<uint64_t, 57>;
-using UInt58 = detail::IntegralType<uint64_t, 58>;
-using UInt59 = detail::IntegralType<uint64_t, 59>;
-using UInt60 = detail::IntegralType<uint64_t, 60>;
-using UInt61 = detail::IntegralType<uint64_t, 61>;
-using UInt62 = detail::IntegralType<uint64_t, 62>;
-using UInt63 = detail::IntegralType<uint64_t, 63>;
+using VarSize = detail::VarIntWrapper<uint32_t, detail::VarIntType::VARSIZE>;
 
 } // namespace zserio
 
diff --git a/runtime/test/zserio/TypesTest.cpp b/runtime/test/zserio/TypesTest.cpp
index 0c8bc08..fe93c44 100644
--- a/runtime/test/zserio/TypesTest.cpp
+++ b/runtime/test/zserio/TypesTest.cpp
@@ -4,256 +4,423 @@
 namespace zserio
 {
 
-template <typename T, typename VALUE_TYPE>
+template <typename T>
 void testSignedStdInt()
 {
-    static_assert(T::MIN_VALUE == std::numeric_limits<VALUE_TYPE>::min(), "shall be constexpr");
-    static_assert(T::MAX_VALUE == std::numeric_limits<VALUE_TYPE>::max(), "shall be constexpr");
+    using value_type = typename T::value_type;
 
-    static_assert(std::is_nothrow_constructible_v<T, typename T::value_type>, "shall be noexcept");
-    static_assert(
-            std::is_nothrow_invocable_v<decltype(&T::set), T, typename T::value_type>, "shall be noexcept");
+    static_assert(zserio::Limits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
+    static_assert(zserio::Limits<T>::max() == std::numeric_limits<value_type>::max(), "shall be constexpr");
 
-    const T minValue(T::MIN_VALUE);
-    ASSERT_EQ(T::MIN_VALUE, minValue);
-    ASSERT_EQ(T::MIN_VALUE, minValue.get());
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(noexcept(checked_cast<T>(std::declval<value_type>())), "shall be noexcept");
 
-    const T maxValue(T::MAX_VALUE);
-    ASSERT_EQ(T::MAX_VALUE, maxValue);
+    const T minValue(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
+
+    const T maxValue(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
+
+    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
+
+    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
 
     T value;
     value = 0;
     ASSERT_EQ(0, value);
-    value.set(1);
-    ASSERT_EQ(1, value.get());
+    value = 1;
+    ASSERT_EQ(1, value);
     value = -1;
     ASSERT_EQ(-1, value);
 }
 
-template <typename T, typename VALUE_TYPE>
+template <typename T>
 void testUnsignedStdInt()
 {
-    static_assert(T::MIN_VALUE == std::numeric_limits<VALUE_TYPE>::min(), "shall be constexpr");
-    static_assert(T::MAX_VALUE == std::numeric_limits<VALUE_TYPE>::max(), "shall be constexpr");
+    using value_type = typename T::value_type;
+
+    static_assert(zserio::Limits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
+    static_assert(zserio::Limits<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(checked_cast<T>(std::declval<value_type>())), "shall be noexcept");
+
+    const T minValue(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
 
-    static_assert(std::is_nothrow_constructible_v<T, typename T::value_type>, "shall be noexcept");
-    static_assert(
-            std::is_nothrow_invocable_v<decltype(&T::set), T, typename T::value_type>, "shall be noexcept");
+    const T maxValue(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
 
-    const T minValue(T::MIN_VALUE);
-    ASSERT_EQ(T::MIN_VALUE, minValue);
-    ASSERT_EQ(T::MIN_VALUE, minValue.get());
+    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
 
-    const T maxValue(T::MAX_VALUE);
-    ASSERT_EQ(T::MAX_VALUE, maxValue);
+    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
 
     T value;
     value = 0;
     ASSERT_EQ(0, value);
-    value.set(1);
-    ASSERT_EQ(1, value.get());
+    value = 1;
+    ASSERT_EQ(1, value);
     value = 2;
     ASSERT_EQ(2, value);
 }
 
-template <typename T, typename T::value_type MIN_VALUE, typename T::value_type MAX_VALUE>
-void testSignedBitField()
+template <typename T, typename T::value_type MIN_VALUE, typename T::value_type MAX_VALUE,
+        bool IS_NOEXCEPT = false>
+void testSignedInt()
 {
-    static_assert(T::MIN_VALUE == MIN_VALUE, "shall be constexpr");
-    static_assert(T::MAX_VALUE == MAX_VALUE, "shall be constexpr");
+    using value_type = typename T::value_type;
+
+    static_assert(zserio::Limits<T>::min() == MIN_VALUE, "shall be constexpr");
+    static_assert(zserio::Limits<T>::max() == MAX_VALUE, "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
 
-    static_assert(!std::is_nothrow_constructible_v<T, typename T::value_type>, "shall be noexcept");
-    static_assert(
-            !std::is_nothrow_invocable_v<decltype(&T::set), T, typename T::value_type>, "shall be noexcept");
+    static_assert(IS_NOEXCEPT == noexcept(checked_cast<T>(std::declval<value_type>())), "unexpected noexcept");
 
-    const T minValue(T::MIN_VALUE);
-    ASSERT_EQ(T::MIN_VALUE, minValue);
-    ASSERT_EQ(T::MIN_VALUE, minValue.get());
+    const T minValue(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
 
-    const T maxValue(T::MAX_VALUE);
-    ASSERT_EQ(T::MAX_VALUE, maxValue);
+    const T maxValue(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
+
+    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
+
+    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
 
     T value;
     ASSERT_EQ(0, value);
-    value.set(-1);
+    value = -1;
     ASSERT_EQ(-1, value);
     value = 0;
     ASSERT_EQ(0, value);
 
-    ASSERT_THROW(T{T::MIN_VALUE - 1}, OutOfRangeException);
-    ASSERT_THROW(value.set(T::MAX_VALUE + 1), OutOfRangeException);
+    if constexpr (!IS_NOEXCEPT)
+    {
+        ASSERT_THROW(zserio::checked_cast<T>(zserio::Limits<T>::min() - 1), OutOfRangeException);
+        ASSERT_THROW(zserio::checked_cast<T>(zserio::Limits<T>::max() + 1), OutOfRangeException);
+        const T underMin = minValue - 1;
+        ASSERT_THROW(zserio::checked_cast(underMin), OutOfRangeException);
+        const T overMax = maxValue + 1;
+        ASSERT_THROW(zserio::checked_cast(overMax), OutOfRangeException);
+    }
 }
 
-template <typename T, typename T::value_type MAX_VALUE>
-void testUnsignedBitField()
+template <typename T, typename T::value_type MAX_VALUE, bool IS_NOEXCEPT = false>
+void testUnsignedInt()
 {
-    static_assert(T::MIN_VALUE == 0, "shall be constexpr");
-    static_assert(T::MAX_VALUE == MAX_VALUE, "shall be constexpr");
+    using value_type = typename T::value_type;
 
-    static_assert(!std::is_nothrow_constructible_v<T, typename T::value_type>, "shall be noexcept");
-    static_assert(
-            !std::is_nothrow_invocable_v<decltype(&T::set), T, typename T::value_type>, "shall be noexcept");
+    static_assert(zserio::Limits<T>::min() == 0, "shall be constexpr");
+    static_assert(zserio::Limits<T>::max() == MAX_VALUE, "shall be constexpr");
 
-    const T minValue(T::MIN_VALUE);
-    ASSERT_EQ(T::MIN_VALUE, minValue);
-    ASSERT_EQ(T::MIN_VALUE, minValue.get());
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(IS_NOEXCEPT == noexcept(checked_cast<T>(std::declval<value_type>())), "unexpected noexcept");
 
-    const T maxValue(T::MAX_VALUE);
-    ASSERT_EQ(T::MAX_VALUE, maxValue);
+    const T minValue(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
+
+    const T maxValue(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
+
+    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
+    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
+
+    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
+    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
 
     T value;
     ASSERT_EQ(0, value);
-    value.set(1);
+    value = 1;
     ASSERT_EQ(1, value);
-    value = T::MAX_VALUE - 1;
-    ASSERT_EQ(T::MAX_VALUE - 1, value);
+    value = zserio::Limits<T>::max() - 1;
+    ASSERT_EQ(zserio::Limits<T>::max() - 1, value);
+
+    if constexpr (!IS_NOEXCEPT)
+    {
+        ASSERT_THROW(zserio::checked_cast<T>(zserio::Limits<T>::max() + 1), OutOfRangeException);
+        const T overMax = maxValue + 1;
+        ASSERT_THROW(zserio::checked_cast(overMax), OutOfRangeException);
+    }
+}
+
+template <typename T>
+void testSignedDynInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(zserio::Limits<T>::min(8) == -128, "shall be constexpr");
+    static_assert(zserio::Limits<T>::max(8) == 127, "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(!noexcept(checked_cast<T>(std::declval<value_type>(), std::declval<BitSize>())),
+            "shall not be noexcept");
+
+    ASSERT_THROW(zserio::checked_cast<T>(0, 0), OutOfRangeException);
+    ASSERT_THROW(zserio::checked_cast<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
+
+    for (BitSize numBits = 1; numBits <= sizeof(value_type) * 8; ++numBits)
+    {
+        const T minValue(zserio::Limits<T>::min(numBits));
+        ASSERT_EQ(zserio::Limits<T>::min(numBits), minValue);
+
+        const T maxValue(zserio::Limits<T>::max(numBits));
+        ASSERT_EQ(zserio::Limits<T>::max(numBits), maxValue);
+
+        T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min(numBits), numBits);
+        ASSERT_EQ(zserio::Limits<T>::min(numBits), checkedMin);
 
-    ASSERT_THROW(T{T::MAX_VALUE + 1}, OutOfRangeException);
-    ASSERT_THROW(value.set(T::MAX_VALUE + 1), OutOfRangeException);
+        T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max(numBits), numBits);
+        ASSERT_EQ(zserio::Limits<T>::max(numBits), checkedMax);
+
+        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(
+                    zserio::checked_cast<T>(zserio::Limits<T>::min(numBits) - 1, numBits), OutOfRangeException)
+                    << numBits;
+            ASSERT_THROW(
+                    zserio::checked_cast<T>(zserio::Limits<T>::max(numBits) + 1, numBits), OutOfRangeException);
+            const T underMin = minValue - 1;
+            ASSERT_THROW(zserio::checked_cast(underMin, numBits), OutOfRangeException);
+            const T overMax = maxValue + 1;
+            ASSERT_THROW(zserio::checked_cast(overMax, numBits), OutOfRangeException);
+        }
+    }
+}
+
+template <typename T>
+void testUnsignedDynInt()
+{
+    using value_type = typename T::value_type;
+
+    static_assert(zserio::Limits<T>::min(8) == 0, "shall be constexpr");
+    static_assert(zserio::Limits<T>::max(8) == 255, "shall be constexpr");
+
+    static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
+    static_assert(!noexcept(checked_cast<T>(std::declval<value_type>(), std::declval<BitSize>())),
+            "shall not be noexcept");
+
+    ASSERT_THROW(zserio::checked_cast<T>(0, 0), OutOfRangeException);
+    ASSERT_THROW(zserio::checked_cast<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
+
+    for (BitSize numBits = 1; numBits <= sizeof(value_type) * 8; ++numBits)
+    {
+        const T minValue(zserio::Limits<T>::min(numBits));
+        ASSERT_EQ(zserio::Limits<T>::min(numBits), minValue);
+
+        const T maxValue(zserio::Limits<T>::max(numBits));
+        ASSERT_EQ(zserio::Limits<T>::max(numBits), maxValue);
+
+        T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min(numBits), numBits);
+        ASSERT_EQ(zserio::Limits<T>::min(numBits), checkedMin);
+
+        T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max(numBits), numBits);
+        ASSERT_EQ(zserio::Limits<T>::max(numBits), checkedMax);
+
+        T value;
+        ASSERT_EQ(0, value);
+        value = 1;
+        ASSERT_EQ(1, value);
+        value = zserio::Limits<T>::max(numBits) - 1;
+        ASSERT_EQ(zserio::Limits<T>::max(numBits) - 1, value);
+
+        if (numBits < sizeof(value_type) * 8)
+        {
+            ASSERT_THROW(
+                    zserio::checked_cast<T>(zserio::Limits<T>::max(numBits) + 1, numBits), OutOfRangeException);
+            const T overMax = maxValue + 1;
+            ASSERT_THROW(zserio::checked_cast(overMax, numBits), OutOfRangeException);
+        }
+    }
 }
 
-TEST(TypesTest, signedStdIntegralTypes)
+TEST(TypesTest, signedStdInts)
 {
-    testSignedStdInt<Int8, int8_t>();
-    testSignedStdInt<Int16, int16_t>();
-    testSignedStdInt<Int32, int32_t>();
-    testSignedStdInt<Int64, int64_t>();
+    testSignedStdInt<Int8>();
+    testSignedStdInt<Int16>();
+    testSignedStdInt<Int32>();
+    testSignedStdInt<Int64>();
 }
 
-TEST(TypesTest, unsignedStdIntegralTypes)
+TEST(TypesTest, unsignedStdInts)
 {
-    testUnsignedStdInt<UInt8, uint8_t>();
-    testUnsignedStdInt<UInt16, uint16_t>();
-    testUnsignedStdInt<UInt32, uint32_t>();
-    testUnsignedStdInt<UInt64, uint64_t>();
+    testUnsignedStdInt<UInt8>();
+    testUnsignedStdInt<UInt16>();
+    testUnsignedStdInt<UInt32>();
+    testUnsignedStdInt<UInt64>();
 }
 
 TEST(TypesTest, signedBitFields)
 {
-    testSignedBitField<Int1, -1, 0>();
-    testSignedBitField<Int2, -2, 1>();
-    testSignedBitField<Int3, -4, 3>();
-    testSignedBitField<Int4, -8, 7>();
-    testSignedBitField<Int5, -16, 15>();
-    testSignedBitField<Int6, -32, 31>();
-    testSignedBitField<Int7, -64, 63>();
-    testSignedBitField<Int9, -256, 255>();
-    testSignedBitField<Int10, -512, 511>();
-    testSignedBitField<Int11, -1024, 1023>();
-    testSignedBitField<Int12, -2048, 2047>();
-    testSignedBitField<Int13, -4096, 4095>();
-    testSignedBitField<Int14, -8192, 8191>();
-    testSignedBitField<Int15, -16384, 16383>();
-    testSignedBitField<Int17, -65536, 65535>();
-    testSignedBitField<Int18, -131072, 131071>();
-    testSignedBitField<Int19, -262144, 262143>();
-    testSignedBitField<Int20, -524288, 524287>();
-    testSignedBitField<Int21, -1048576, 1048575>();
-    testSignedBitField<Int22, -2097152, 2097151>();
-    testSignedBitField<Int23, -4194304, 4194303>();
-    testSignedBitField<Int24, -8388608, 8388607>();
-    testSignedBitField<Int25, -16777216, 16777215>();
-    testSignedBitField<Int26, -33554432, 33554431>();
-    testSignedBitField<Int27, -67108864, 67108863>();
-    testSignedBitField<Int28, -134217728, 134217727>();
-    testSignedBitField<Int29, -268435456, 268435455>();
-    testSignedBitField<Int30, -536870912, 536870911>();
-    testSignedBitField<Int31, -1073741824, 1073741823>();
-    testSignedBitField<Int33, -4294967296LL, 4294967295LL>();
-    testSignedBitField<Int34, -8589934592LL, 8589934591LL>();
-    testSignedBitField<Int35, -17179869184LL, 17179869183LL>();
-    testSignedBitField<Int36, -34359738368LL, 34359738367LL>();
-    testSignedBitField<Int37, -68719476736LL, 68719476735LL>();
-    testSignedBitField<Int38, -137438953472LL, 137438953471LL>();
-    testSignedBitField<Int39, -274877906944LL, 274877906943LL>();
-    testSignedBitField<Int40, -549755813888LL, 549755813887LL>();
-    testSignedBitField<Int41, -1099511627776LL, 1099511627775LL>();
-    testSignedBitField<Int42, -2199023255552LL, 2199023255551LL>();
-    testSignedBitField<Int43, -4398046511104LL, 4398046511103LL>();
-    testSignedBitField<Int44, -8796093022208LL, 8796093022207LL>();
-    testSignedBitField<Int45, -17592186044416LL, 17592186044415LL>();
-    testSignedBitField<Int46, -35184372088832LL, 35184372088831LL>();
-    testSignedBitField<Int47, -70368744177664LL, 70368744177663LL>();
-    testSignedBitField<Int48, -140737488355328LL, 140737488355327LL>();
-    testSignedBitField<Int49, -281474976710656LL, 281474976710655LL>();
-    testSignedBitField<Int50, -562949953421312LL, 562949953421311LL>();
-    testSignedBitField<Int51, -1125899906842624LL, 1125899906842623LL>();
-    testSignedBitField<Int52, -2251799813685248LL, 2251799813685247LL>();
-    testSignedBitField<Int53, -4503599627370496LL, 4503599627370495LL>();
-    testSignedBitField<Int54, -9007199254740992LL, 9007199254740991LL>();
-    testSignedBitField<Int55, -18014398509481984LL, 18014398509481983LL>();
-    testSignedBitField<Int56, -36028797018963968LL, 36028797018963967LL>();
-    testSignedBitField<Int57, -72057594037927936LL, 72057594037927935LL>();
-    testSignedBitField<Int58, -144115188075855872LL, 144115188075855871LL>();
-    testSignedBitField<Int59, -288230376151711744LL, 288230376151711743LL>();
-    testSignedBitField<Int60, -576460752303423488LL, 576460752303423487LL>();
-    testSignedBitField<Int61, -1152921504606846976LL, 1152921504606846975LL>();
-    testSignedBitField<Int62, -2305843009213693952LL, 2305843009213693951LL>();
-    testSignedBitField<Int63, -4611686018427387904LL, 4611686018427387903LL>();
+    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, unsignedBitFields)
 {
-    testUnsignedBitField<UInt1, 1ULL>();
-    testUnsignedBitField<UInt2, 3ULL>();
-    testUnsignedBitField<UInt3, 7ULL>();
-    testUnsignedBitField<UInt4, 15ULL>();
-    testUnsignedBitField<UInt5, 31ULL>();
-    testUnsignedBitField<UInt6, 63ULL>();
-    testUnsignedBitField<UInt7, 127ULL>();
-    testUnsignedBitField<UInt9, 511ULL>();
-    testUnsignedBitField<UInt10, 1023ULL>();
-    testUnsignedBitField<UInt11, 2047ULL>();
-    testUnsignedBitField<UInt12, 4095ULL>();
-    testUnsignedBitField<UInt13, 8191ULL>();
-    testUnsignedBitField<UInt14, 16383ULL>();
-    testUnsignedBitField<UInt15, 32767ULL>();
-    testUnsignedBitField<UInt17, 131071ULL>();
-    testUnsignedBitField<UInt18, 262143ULL>();
-    testUnsignedBitField<UInt19, 524287ULL>();
-    testUnsignedBitField<UInt20, 1048575ULL>();
-    testUnsignedBitField<UInt21, 2097151ULL>();
-    testUnsignedBitField<UInt22, 4194303ULL>();
-    testUnsignedBitField<UInt23, 8388607ULL>();
-    testUnsignedBitField<UInt24, 16777215ULL>();
-    testUnsignedBitField<UInt25, 33554431ULL>();
-    testUnsignedBitField<UInt26, 67108863ULL>();
-    testUnsignedBitField<UInt27, 134217727ULL>();
-    testUnsignedBitField<UInt28, 268435455ULL>();
-    testUnsignedBitField<UInt29, 536870911ULL>();
-    testUnsignedBitField<UInt30, 1073741823ULL>();
-    testUnsignedBitField<UInt31, 2147483647ULL>();
-    testUnsignedBitField<UInt33, 8589934591ULL>();
-    testUnsignedBitField<UInt34, 17179869183ULL>();
-    testUnsignedBitField<UInt35, 34359738367ULL>();
-    testUnsignedBitField<UInt36, 68719476735ULL>();
-    testUnsignedBitField<UInt37, 137438953471ULL>();
-    testUnsignedBitField<UInt38, 274877906943ULL>();
-    testUnsignedBitField<UInt39, 549755813887ULL>();
-    testUnsignedBitField<UInt40, 1099511627775ULL>();
-    testUnsignedBitField<UInt41, 2199023255551ULL>();
-    testUnsignedBitField<UInt42, 4398046511103ULL>();
-    testUnsignedBitField<UInt43, 8796093022207ULL>();
-    testUnsignedBitField<UInt44, 17592186044415ULL>();
-    testUnsignedBitField<UInt45, 35184372088831ULL>();
-    testUnsignedBitField<UInt46, 70368744177663ULL>();
-    testUnsignedBitField<UInt47, 140737488355327ULL>();
-    testUnsignedBitField<UInt48, 281474976710655ULL>();
-    testUnsignedBitField<UInt49, 562949953421311ULL>();
-    testUnsignedBitField<UInt50, 1125899906842623ULL>();
-    testUnsignedBitField<UInt51, 2251799813685247ULL>();
-    testUnsignedBitField<UInt52, 4503599627370495ULL>();
-    testUnsignedBitField<UInt53, 9007199254740991ULL>();
-    testUnsignedBitField<UInt54, 18014398509481983ULL>();
-    testUnsignedBitField<UInt55, 36028797018963967ULL>();
-    testUnsignedBitField<UInt56, 72057594037927935ULL>();
-    testUnsignedBitField<UInt57, 144115188075855871ULL>();
-    testUnsignedBitField<UInt58, 288230376151711743ULL>();
-    testUnsignedBitField<UInt59, 576460752303423487ULL>();
-    testUnsignedBitField<UInt60, 1152921504606846975ULL>();
-    testUnsignedBitField<UInt61, 2305843009213693951ULL>();
-    testUnsignedBitField<UInt62, 4611686018427387903ULL>();
-    testUnsignedBitField<UInt63, 9223372036854775807ULL>();
+    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, signedVarInts)
+{
+    testSignedInt<VarInt16, -16383, 16383>();
+    testSignedInt<VarInt32, -268435455, 268435455>();
+    testSignedInt<VarInt64, -72057594037927935LL, 72057594037927935LL>();
+    testSignedInt<VarInt, INT64_MIN, INT64_MAX, true>();
+}
+
+TEST(TypesTest, unsignedVarInts)
+{
+    testUnsignedInt<VarUInt16, 32767>();
+    testUnsignedInt<VarUInt32, 536870911>();
+    testUnsignedInt<VarUInt64, 144115188075855871ULL>();
+    testUnsignedInt<VarUInt, UINT64_MAX, true>();
+    testUnsignedInt<VarSize, 2147483647>();
+}
+
+TEST(TypesTest, signedDynInts)
+{
+    testSignedDynInt<DynInt8>();
+    testSignedDynInt<DynInt16>();
+    testSignedDynInt<DynInt32>();
+    testSignedDynInt<DynInt64>();
+}
+
+TEST(TypesTest, unsignedDynInts)
+{
+    testUnsignedDynInt<DynUInt8>();
+    testUnsignedDynInt<DynUInt16>();
+    testUnsignedDynInt<DynUInt32>();
+    testUnsignedDynInt<DynUInt64>();
 }
 
 } // namespace zserio