diff --git a/src/config.rs b/src/config.rs
index 60b847f..8f3334e 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -173,11 +173,31 @@ impl<E, I, L> Configuration<E, I, L> {
 pub trait Config:
     InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone
 {
+    /// This configuration's Endianness
+    fn endianness(&self) -> Endianness;
+
+    /// This configuration's Integer Encoding
+    fn int_encoding(&self) -> IntEncoding;
+
+    /// This configuration's byte limit, or `None` if no limit is configured
+    fn limit(&self) -> Option<usize>;
 }
 
-impl<T> Config for T where
-    T: InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone
+impl<T> Config for T
+where
+    T: InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone,
 {
+    fn endianness(&self) -> Endianness {
+        <T as InternalEndianConfig>::ENDIAN
+    }
+
+    fn int_encoding(&self) -> IntEncoding {
+        <T as InternalIntEncodingConfig>::INT_ENCODING
+    }
+
+    fn limit(&self) -> Option<usize> {
+        <T as InternalLimitConfig>::LIMIT
+    }
 }
 
 /// Encodes all integer types in big endian.
@@ -185,7 +205,7 @@ impl<T> Config for T where
 pub struct BigEndian {}
 
 impl InternalEndianConfig for BigEndian {
-    const ENDIAN: Endian = Endian::Big;
+    const ENDIAN: Endianness = Endianness::Big;
 }
 
 /// Encodes all integer types in little endian.
@@ -193,7 +213,7 @@ impl InternalEndianConfig for BigEndian {
 pub struct LittleEndian {}
 
 impl InternalEndianConfig for LittleEndian {
-    const ENDIAN: Endian = Endian::Little;
+    const ENDIAN: Endianness = Endianness::Little;
 }
 
 /// Use fixed-size integer encoding.
@@ -226,21 +246,35 @@ impl<const N: usize> InternalLimitConfig for Limit<N> {
     const LIMIT: Option<usize> = Some(N);
 }
 
+/// Endianness of a `Configuration`.
+#[derive(PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Endianness {
+    /// Little Endian encoding, see `LittleEndian`.
+    Little,
+    /// Big Endian encoding, see `BigEndian`.
+    Big,
+}
+
+/// Integer Encoding of a `Configuration`.
+#[derive(PartialEq, Eq)]
+#[non_exhaustive]
+pub enum IntEncoding {
+    /// Fixed Integer Encoding, see `Fixint`.
+    Fixed,
+    /// Variable Integer Encoding, see `Varint`.
+    Variable,
+}
+
 mod internal {
-    use super::Configuration;
+    use super::{Configuration, Endianness, IntEncoding};
 
     pub trait InternalEndianConfig {
-        const ENDIAN: Endian;
+        const ENDIAN: Endianness;
     }
 
     impl<E: InternalEndianConfig, I, L> InternalEndianConfig for Configuration<E, I, L> {
-        const ENDIAN: Endian = E::ENDIAN;
-    }
-
-    #[derive(PartialEq, Eq)]
-    pub enum Endian {
-        Little,
-        Big,
+        const ENDIAN: Endianness = E::ENDIAN;
     }
 
     pub trait InternalIntEncodingConfig {
@@ -251,12 +285,6 @@ mod internal {
         const INT_ENCODING: IntEncoding = I::INT_ENCODING;
     }
 
-    #[derive(PartialEq, Eq)]
-    pub enum IntEncoding {
-        Fixed,
-        Variable,
-    }
-
     pub trait InternalLimitConfig {
         const LIMIT: Option<usize>;
     }
diff --git a/src/de/impls.rs b/src/de/impls.rs
index 202be03..fd4f42e 100644
--- a/src/de/impls.rs
+++ b/src/de/impls.rs
@@ -3,7 +3,7 @@ use super::{
     BorrowDecode, BorrowDecoder, Decode, Decoder,
 };
 use crate::{
-    config::{Endian, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
+    config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
     error::{DecodeError, IntegerType},
     impl_borrow_decode,
 };
@@ -65,8 +65,8 @@ impl Decode for u16 {
                 let mut bytes = [0u8; 2];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => u16::from_le_bytes(bytes),
-                    Endian::Big => u16::from_be_bytes(bytes),
+                    Endianness::Little => u16::from_le_bytes(bytes),
+                    Endianness::Big => u16::from_be_bytes(bytes),
                 })
             }
         }
@@ -94,8 +94,8 @@ impl Decode for u32 {
                 let mut bytes = [0u8; 4];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => u32::from_le_bytes(bytes),
-                    Endian::Big => u32::from_be_bytes(bytes),
+                    Endianness::Little => u32::from_le_bytes(bytes),
+                    Endianness::Big => u32::from_be_bytes(bytes),
                 })
             }
         }
@@ -123,8 +123,8 @@ impl Decode for u64 {
                 let mut bytes = [0u8; 8];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => u64::from_le_bytes(bytes),
-                    Endian::Big => u64::from_be_bytes(bytes),
+                    Endianness::Little => u64::from_le_bytes(bytes),
+                    Endianness::Big => u64::from_be_bytes(bytes),
                 })
             }
         }
@@ -152,8 +152,8 @@ impl Decode for u128 {
                 let mut bytes = [0u8; 16];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => u128::from_le_bytes(bytes),
-                    Endian::Big => u128::from_be_bytes(bytes),
+                    Endianness::Little => u128::from_le_bytes(bytes),
+                    Endianness::Big => u128::from_be_bytes(bytes),
                 })
             }
         }
@@ -182,8 +182,8 @@ impl Decode for usize {
                 decoder.reader().read(&mut bytes)?;
 
                 let value = match D::C::ENDIAN {
-                    Endian::Little => u64::from_le_bytes(bytes),
-                    Endian::Big => u64::from_be_bytes(bytes),
+                    Endianness::Little => u64::from_le_bytes(bytes),
+                    Endianness::Big => u64::from_be_bytes(bytes),
                 };
 
                 value
@@ -234,8 +234,8 @@ impl Decode for i16 {
                 let mut bytes = [0u8; 2];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => i16::from_le_bytes(bytes),
-                    Endian::Big => i16::from_be_bytes(bytes),
+                    Endianness::Little => i16::from_le_bytes(bytes),
+                    Endianness::Big => i16::from_be_bytes(bytes),
                 })
             }
         }
@@ -263,8 +263,8 @@ impl Decode for i32 {
                 let mut bytes = [0u8; 4];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => i32::from_le_bytes(bytes),
-                    Endian::Big => i32::from_be_bytes(bytes),
+                    Endianness::Little => i32::from_le_bytes(bytes),
+                    Endianness::Big => i32::from_be_bytes(bytes),
                 })
             }
         }
@@ -292,8 +292,8 @@ impl Decode for i64 {
                 let mut bytes = [0u8; 8];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => i64::from_le_bytes(bytes),
-                    Endian::Big => i64::from_be_bytes(bytes),
+                    Endianness::Little => i64::from_le_bytes(bytes),
+                    Endianness::Big => i64::from_be_bytes(bytes),
                 })
             }
         }
@@ -321,8 +321,8 @@ impl Decode for i128 {
                 let mut bytes = [0u8; 16];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => i128::from_le_bytes(bytes),
-                    Endian::Big => i128::from_be_bytes(bytes),
+                    Endianness::Little => i128::from_le_bytes(bytes),
+                    Endianness::Big => i128::from_be_bytes(bytes),
                 })
             }
         }
@@ -350,8 +350,8 @@ impl Decode for isize {
                 let mut bytes = [0u8; 8];
                 decoder.reader().read(&mut bytes)?;
                 Ok(match D::C::ENDIAN {
-                    Endian::Little => i64::from_le_bytes(bytes),
-                    Endian::Big => i64::from_be_bytes(bytes),
+                    Endianness::Little => i64::from_le_bytes(bytes),
+                    Endianness::Big => i64::from_be_bytes(bytes),
                 } as isize)
             }
         }
@@ -374,8 +374,8 @@ impl Decode for f32 {
         let mut bytes = [0u8; 4];
         decoder.reader().read(&mut bytes)?;
         Ok(match D::C::ENDIAN {
-            Endian::Little => f32::from_le_bytes(bytes),
-            Endian::Big => f32::from_be_bytes(bytes),
+            Endianness::Little => f32::from_le_bytes(bytes),
+            Endianness::Big => f32::from_be_bytes(bytes),
         })
     }
 }
@@ -387,8 +387,8 @@ impl Decode for f64 {
         let mut bytes = [0u8; 8];
         decoder.reader().read(&mut bytes)?;
         Ok(match D::C::ENDIAN {
-            Endian::Little => f64::from_le_bytes(bytes),
-            Endian::Big => f64::from_be_bytes(bytes),
+            Endianness::Little => f64::from_le_bytes(bytes),
+            Endianness::Big => f64::from_be_bytes(bytes),
         })
     }
 }
diff --git a/src/enc/impls.rs b/src/enc/impls.rs
index a6d904f..efaadac 100644
--- a/src/enc/impls.rs
+++ b/src/enc/impls.rs
@@ -1,6 +1,6 @@
 use super::{write::Writer, Encode, Encoder};
 use crate::{
-    config::{Endian, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
+    config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
     error::EncodeError,
 };
 use core::{
@@ -51,8 +51,8 @@ impl Encode for u16 {
                 crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -71,8 +71,8 @@ impl Encode for u32 {
                 crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -91,8 +91,8 @@ impl Encode for u64 {
                 crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -111,8 +111,8 @@ impl Encode for u128 {
                 crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -131,8 +131,8 @@ impl Encode for usize {
                 crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&(*self as u64).to_be_bytes()),
-                Endian::Little => encoder.writer().write(&(*self as u64).to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&(*self as u64).to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&(*self as u64).to_le_bytes()),
             },
         }
     }
@@ -163,8 +163,8 @@ impl Encode for i16 {
                 crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -183,8 +183,8 @@ impl Encode for i32 {
                 crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -203,8 +203,8 @@ impl Encode for i64 {
                 crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -223,8 +223,8 @@ impl Encode for i128 {
                 crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-                Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
             },
         }
     }
@@ -243,8 +243,8 @@ impl Encode for isize {
                 crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self)
             }
             IntEncoding::Fixed => match E::C::ENDIAN {
-                Endian::Big => encoder.writer().write(&(*self as i64).to_be_bytes()),
-                Endian::Little => encoder.writer().write(&(*self as i64).to_le_bytes()),
+                Endianness::Big => encoder.writer().write(&(*self as i64).to_be_bytes()),
+                Endianness::Little => encoder.writer().write(&(*self as i64).to_le_bytes()),
             },
         }
     }
@@ -259,8 +259,8 @@ impl Encode for NonZeroIsize {
 impl Encode for f32 {
     fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
         match E::C::ENDIAN {
-            Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-            Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+            Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+            Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
         }
     }
 }
@@ -268,8 +268,8 @@ impl Encode for f32 {
 impl Encode for f64 {
     fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
         match E::C::ENDIAN {
-            Endian::Big => encoder.writer().write(&self.to_be_bytes()),
-            Endian::Little => encoder.writer().write(&self.to_le_bytes()),
+            Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
+            Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
         }
     }
 }
diff --git a/src/varint/decode_signed.rs b/src/varint/decode_signed.rs
index d670493..cae4e4f 100644
--- a/src/varint/decode_signed.rs
+++ b/src/varint/decode_signed.rs
@@ -1,10 +1,10 @@
 use crate::{
-    config::Endian,
+    config::Endianness,
     de::read::Reader,
     error::{DecodeError, IntegerType},
 };
 
-pub fn varint_decode_i16<R: Reader>(read: &mut R, endian: Endian) -> Result<i16, DecodeError> {
+pub fn varint_decode_i16<R: Reader>(read: &mut R, endian: Endianness) -> Result<i16, DecodeError> {
     let n = super::varint_decode_u16(read, endian)
         .map_err(DecodeError::change_integer_type_to_signed)?;
     Ok(if n % 2 == 0 {
@@ -21,7 +21,7 @@ pub fn varint_decode_i16<R: Reader>(read: &mut R, endian: Endian) -> Result<i16,
     })
 }
 
-pub fn varint_decode_i32<R: Reader>(read: &mut R, endian: Endian) -> Result<i32, DecodeError> {
+pub fn varint_decode_i32<R: Reader>(read: &mut R, endian: Endianness) -> Result<i32, DecodeError> {
     let n = super::varint_decode_u32(read, endian)
         .map_err(DecodeError::change_integer_type_to_signed)?;
     Ok(if n % 2 == 0 {
@@ -38,7 +38,7 @@ pub fn varint_decode_i32<R: Reader>(read: &mut R, endian: Endian) -> Result<i32,
     })
 }
 
-pub fn varint_decode_i64<R: Reader>(read: &mut R, endian: Endian) -> Result<i64, DecodeError> {
+pub fn varint_decode_i64<R: Reader>(read: &mut R, endian: Endianness) -> Result<i64, DecodeError> {
     let n = super::varint_decode_u64(read, endian)
         .map_err(DecodeError::change_integer_type_to_signed)?;
     Ok(if n % 2 == 0 {
@@ -55,7 +55,10 @@ pub fn varint_decode_i64<R: Reader>(read: &mut R, endian: Endian) -> Result<i64,
     })
 }
 
-pub fn varint_decode_i128<R: Reader>(read: &mut R, endian: Endian) -> Result<i128, DecodeError> {
+pub fn varint_decode_i128<R: Reader>(
+    read: &mut R,
+    endian: Endianness,
+) -> Result<i128, DecodeError> {
     let n = super::varint_decode_u128(read, endian)
         .map_err(DecodeError::change_integer_type_to_signed)?;
     Ok(if n % 2 == 0 {
@@ -72,7 +75,10 @@ pub fn varint_decode_i128<R: Reader>(read: &mut R, endian: Endian) -> Result<i12
     })
 }
 
-pub fn varint_decode_isize<R: Reader>(read: &mut R, endian: Endian) -> Result<isize, DecodeError> {
+pub fn varint_decode_isize<R: Reader>(
+    read: &mut R,
+    endian: Endianness,
+) -> Result<isize, DecodeError> {
     match varint_decode_i64(read, endian) {
         Ok(val) => Ok(val as isize),
         Err(DecodeError::InvalidIntegerType { found, .. }) => {
diff --git a/src/varint/decode_unsigned.rs b/src/varint/decode_unsigned.rs
index 1aa57a8..d6b17a6 100644
--- a/src/varint/decode_unsigned.rs
+++ b/src/varint/decode_unsigned.rs
@@ -2,14 +2,14 @@ use core::{convert::TryInto, u32};
 
 use super::{SINGLE_BYTE_MAX, U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE};
 use crate::{
-    config::Endian,
+    config::Endianness,
     de::read::Reader,
     error::{DecodeError, IntegerType},
 };
 
 #[inline(never)]
 #[cold]
-fn deserialize_varint_cold_u16<R>(read: &mut R, endian: Endian) -> Result<u16, DecodeError>
+fn deserialize_varint_cold_u16<R>(read: &mut R, endian: Endianness) -> Result<u16, DecodeError>
 where
     R: Reader,
 {
@@ -21,8 +21,8 @@ where
             let mut bytes = [0u8; 2];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u16::from_be_bytes(bytes),
-                Endian::Little => u16::from_le_bytes(bytes),
+                Endianness::Big => u16::from_be_bytes(bytes),
+                Endianness::Little => u16::from_le_bytes(bytes),
             })
         }
         U32_BYTE => invalid_varint_discriminant(IntegerType::U16, IntegerType::U32),
@@ -34,7 +34,7 @@ where
 
 #[inline(never)]
 #[cold]
-fn deserialize_varint_cold_u32<R>(read: &mut R, endian: Endian) -> Result<u32, DecodeError>
+fn deserialize_varint_cold_u32<R>(read: &mut R, endian: Endianness) -> Result<u32, DecodeError>
 where
     R: Reader,
 {
@@ -46,16 +46,16 @@ where
             let mut bytes = [0u8; 2];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u16::from_be_bytes(bytes) as u32,
-                Endian::Little => u16::from_le_bytes(bytes) as u32,
+                Endianness::Big => u16::from_be_bytes(bytes) as u32,
+                Endianness::Little => u16::from_le_bytes(bytes) as u32,
             })
         }
         U32_BYTE => {
             let mut bytes = [0u8; 4];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u32::from_be_bytes(bytes),
-                Endian::Little => u32::from_le_bytes(bytes),
+                Endianness::Big => u32::from_be_bytes(bytes),
+                Endianness::Little => u32::from_le_bytes(bytes),
             })
         }
         U64_BYTE => invalid_varint_discriminant(IntegerType::U32, IntegerType::U64),
@@ -66,7 +66,7 @@ where
 
 #[inline(never)]
 #[cold]
-fn deserialize_varint_cold_u64<R>(read: &mut R, endian: Endian) -> Result<u64, DecodeError>
+fn deserialize_varint_cold_u64<R>(read: &mut R, endian: Endianness) -> Result<u64, DecodeError>
 where
     R: Reader,
 {
@@ -78,24 +78,24 @@ where
             let mut bytes = [0u8; 2];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u16::from_be_bytes(bytes) as u64,
-                Endian::Little => u16::from_le_bytes(bytes) as u64,
+                Endianness::Big => u16::from_be_bytes(bytes) as u64,
+                Endianness::Little => u16::from_le_bytes(bytes) as u64,
             })
         }
         U32_BYTE => {
             let mut bytes = [0u8; 4];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u32::from_be_bytes(bytes) as u64,
-                Endian::Little => u32::from_le_bytes(bytes) as u64,
+                Endianness::Big => u32::from_be_bytes(bytes) as u64,
+                Endianness::Little => u32::from_le_bytes(bytes) as u64,
             })
         }
         U64_BYTE => {
             let mut bytes = [0u8; 8];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u64::from_be_bytes(bytes),
-                Endian::Little => u64::from_le_bytes(bytes),
+                Endianness::Big => u64::from_be_bytes(bytes),
+                Endianness::Little => u64::from_le_bytes(bytes),
             })
         }
         U128_BYTE => invalid_varint_discriminant(IntegerType::U64, IntegerType::U128),
@@ -105,7 +105,7 @@ where
 
 #[inline(never)]
 #[cold]
-fn deserialize_varint_cold_usize<R>(read: &mut R, endian: Endian) -> Result<usize, DecodeError>
+fn deserialize_varint_cold_usize<R>(read: &mut R, endian: Endianness) -> Result<usize, DecodeError>
 where
     R: Reader,
 {
@@ -117,24 +117,24 @@ where
             let mut bytes = [0u8; 2];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u16::from_be_bytes(bytes) as usize,
-                Endian::Little => u16::from_le_bytes(bytes) as usize,
+                Endianness::Big => u16::from_be_bytes(bytes) as usize,
+                Endianness::Little => u16::from_le_bytes(bytes) as usize,
             })
         }
         U32_BYTE => {
             let mut bytes = [0u8; 4];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u32::from_be_bytes(bytes) as usize,
-                Endian::Little => u32::from_le_bytes(bytes) as usize,
+                Endianness::Big => u32::from_be_bytes(bytes) as usize,
+                Endianness::Little => u32::from_le_bytes(bytes) as usize,
             })
         }
         U64_BYTE => {
             let mut bytes = [0u8; 8];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u64::from_be_bytes(bytes) as usize,
-                Endian::Little => u64::from_le_bytes(bytes) as usize,
+                Endianness::Big => u64::from_be_bytes(bytes) as usize,
+                Endianness::Little => u64::from_le_bytes(bytes) as usize,
             })
         }
         U128_BYTE => invalid_varint_discriminant(IntegerType::Usize, IntegerType::U128),
@@ -144,7 +144,7 @@ where
 
 #[inline(never)]
 #[cold]
-fn deserialize_varint_cold_u128<R>(read: &mut R, endian: Endian) -> Result<u128, DecodeError>
+fn deserialize_varint_cold_u128<R>(read: &mut R, endian: Endianness) -> Result<u128, DecodeError>
 where
     R: Reader,
 {
@@ -156,32 +156,32 @@ where
             let mut bytes = [0u8; 2];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u16::from_be_bytes(bytes) as u128,
-                Endian::Little => u16::from_le_bytes(bytes) as u128,
+                Endianness::Big => u16::from_be_bytes(bytes) as u128,
+                Endianness::Little => u16::from_le_bytes(bytes) as u128,
             })
         }
         U32_BYTE => {
             let mut bytes = [0u8; 4];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u32::from_be_bytes(bytes) as u128,
-                Endian::Little => u32::from_le_bytes(bytes) as u128,
+                Endianness::Big => u32::from_be_bytes(bytes) as u128,
+                Endianness::Little => u32::from_le_bytes(bytes) as u128,
             })
         }
         U64_BYTE => {
             let mut bytes = [0u8; 8];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u64::from_be_bytes(bytes) as u128,
-                Endian::Little => u64::from_le_bytes(bytes) as u128,
+                Endianness::Big => u64::from_be_bytes(bytes) as u128,
+                Endianness::Little => u64::from_le_bytes(bytes) as u128,
             })
         }
         U128_BYTE => {
             let mut bytes = [0u8; 16];
             read.read(&mut bytes)?;
             Ok(match endian {
-                Endian::Big => u128::from_be_bytes(bytes),
-                Endian::Little => u128::from_le_bytes(bytes),
+                Endianness::Big => u128::from_be_bytes(bytes),
+                Endianness::Little => u128::from_le_bytes(bytes),
             })
         }
         _ => invalid_varint_discriminant(IntegerType::U128, IntegerType::Reserved),
@@ -197,15 +197,15 @@ fn invalid_varint_discriminant<T>(
     Err(DecodeError::InvalidIntegerType { expected, found })
 }
 
-pub fn varint_decode_u16<R: Reader>(read: &mut R, endian: Endian) -> Result<u16, DecodeError> {
+pub fn varint_decode_u16<R: Reader>(read: &mut R, endian: Endianness) -> Result<u16, DecodeError> {
     if let Some(bytes) = read.peek_read(3) {
         let (discriminant, bytes) = bytes.split_at(1);
         let (out, used) = match discriminant[0] {
             byte @ 0..=SINGLE_BYTE_MAX => (byte as u16, 1),
             U16_BYTE => {
                 let val = match endian {
-                    Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
-                    Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
                 };
 
                 (val, 3)
@@ -223,23 +223,23 @@ pub fn varint_decode_u16<R: Reader>(read: &mut R, endian: Endian) -> Result<u16,
     }
 }
 
-pub fn varint_decode_u32<R: Reader>(read: &mut R, endian: Endian) -> Result<u32, DecodeError> {
+pub fn varint_decode_u32<R: Reader>(read: &mut R, endian: Endianness) -> Result<u32, DecodeError> {
     if let Some(bytes) = read.peek_read(5) {
         let (discriminant, bytes) = bytes.split_at(1);
         let (out, used) = match discriminant[0] {
             byte @ 0..=SINGLE_BYTE_MAX => (byte as u32, 1),
             U16_BYTE => {
                 let val = match endian {
-                    Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
-                    Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
                 };
 
                 (val as u32, 3)
             }
             U32_BYTE => {
                 let val = match endian {
-                    Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
-                    Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
                 };
 
                 (val, 5)
@@ -256,31 +256,31 @@ pub fn varint_decode_u32<R: Reader>(read: &mut R, endian: Endian) -> Result<u32,
     }
 }
 
-pub fn varint_decode_u64<R: Reader>(read: &mut R, endian: Endian) -> Result<u64, DecodeError> {
+pub fn varint_decode_u64<R: Reader>(read: &mut R, endian: Endianness) -> Result<u64, DecodeError> {
     if let Some(bytes) = read.peek_read(9) {
         let (discriminant, bytes) = bytes.split_at(1);
         let (out, used) = match discriminant[0] {
             byte @ 0..=SINGLE_BYTE_MAX => (byte as u64, 1),
             U16_BYTE => {
                 let val = match endian {
-                    Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
-                    Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
                 };
 
                 (val as u64, 3)
             }
             U32_BYTE => {
                 let val = match endian {
-                    Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
-                    Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
                 };
 
                 (val as u64, 5)
             }
             U64_BYTE => {
                 let val = match endian {
-                    Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
-                    Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
+                    Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
+                    Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
                 };
 
                 (val, 9)
@@ -296,31 +296,34 @@ pub fn varint_decode_u64<R: Reader>(read: &mut R, endian: Endian) -> Result<u64,
     }
 }
 
-pub fn varint_decode_usize<R: Reader>(read: &mut R, endian: Endian) -> Result<usize, DecodeError> {
+pub fn varint_decode_usize<R: Reader>(
+    read: &mut R,
+    endian: Endianness,
+) -> Result<usize, DecodeError> {
     if let Some(bytes) = read.peek_read(9) {
         let (discriminant, bytes) = bytes.split_at(1);
         let (out, used) = match discriminant[0] {
             byte @ 0..=SINGLE_BYTE_MAX => (byte as usize, 1),
             U16_BYTE => {
                 let val = match endian {
-                    Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
-                    Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
                 };
 
                 (val as usize, 3)
             }
             U32_BYTE => {
                 let val = match endian {
-                    Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
-                    Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
                 };
 
                 (val as usize, 5)
             }
             U64_BYTE => {
                 let val = match endian {
-                    Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
-                    Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
+                    Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
+                    Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
                 };
 
                 (val as usize, 9)
@@ -336,39 +339,42 @@ pub fn varint_decode_usize<R: Reader>(read: &mut R, endian: Endian) -> Result<us
     }
 }
 
-pub fn varint_decode_u128<R: Reader>(read: &mut R, endian: Endian) -> Result<u128, DecodeError> {
+pub fn varint_decode_u128<R: Reader>(
+    read: &mut R,
+    endian: Endianness,
+) -> Result<u128, DecodeError> {
     if let Some(bytes) = read.peek_read(17) {
         let (discriminant, bytes) = bytes.split_at(1);
         let (out, used) = match discriminant[0] {
             byte @ 0..=SINGLE_BYTE_MAX => (byte as u128, 1),
             U16_BYTE => {
                 let val = match endian {
-                    Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
-                    Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
+                    Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
                 };
 
                 (val as u128, 3)
             }
             U32_BYTE => {
                 let val = match endian {
-                    Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
-                    Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
+                    Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
                 };
 
                 (val as u128, 5)
             }
             U64_BYTE => {
                 let val = match endian {
-                    Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
-                    Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
+                    Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
+                    Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
                 };
 
                 (val as u128, 9)
             }
             U128_BYTE => {
                 let val = match endian {
-                    Endian::Big => u128::from_be_bytes(bytes[..16].try_into().unwrap()),
-                    Endian::Little => u128::from_le_bytes(bytes[..16].try_into().unwrap()),
+                    Endianness::Big => u128::from_be_bytes(bytes[..16].try_into().unwrap()),
+                    Endianness::Little => u128::from_le_bytes(bytes[..16].try_into().unwrap()),
                 };
 
                 (val, 17)
@@ -392,11 +398,11 @@ fn test_decode_u16() {
     ];
     for &(slice, expected_le, expected_be) in cases {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u16(&mut reader, Endian::Little).unwrap();
+        let found = varint_decode_u16(&mut reader, Endianness::Little).unwrap();
         assert_eq!(expected_le, found);
 
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u16(&mut reader, Endian::Big).unwrap();
+        let found = varint_decode_u16(&mut reader, Endianness::Big).unwrap();
         assert_eq!(expected_be, found);
     }
 
@@ -428,7 +434,7 @@ fn test_decode_u16() {
 
     for (slice, expected) in errors {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u16(&mut reader, Endian::Little).unwrap_err();
+        let found = varint_decode_u16(&mut reader, Endianness::Little).unwrap_err();
         assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
     }
 }
@@ -443,11 +449,11 @@ fn test_decode_u32() {
     ];
     for &(slice, expected_le, expected_be) in cases {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u32(&mut reader, Endian::Little).unwrap();
+        let found = varint_decode_u32(&mut reader, Endianness::Little).unwrap();
         assert_eq!(expected_le, found);
 
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u32(&mut reader, Endian::Big).unwrap();
+        let found = varint_decode_u32(&mut reader, Endianness::Big).unwrap();
         assert_eq!(expected_be, found);
     }
 
@@ -482,7 +488,7 @@ fn test_decode_u32() {
 
     for (slice, expected) in errors {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u32(&mut reader, Endian::Little).unwrap_err();
+        let found = varint_decode_u32(&mut reader, Endianness::Little).unwrap_err();
         assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
     }
 }
@@ -502,11 +508,11 @@ fn test_decode_u64() {
     ];
     for &(slice, expected_le, expected_be) in cases {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u64(&mut reader, Endian::Little).unwrap();
+        let found = varint_decode_u64(&mut reader, Endianness::Little).unwrap();
         assert_eq!(expected_le, found);
 
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u64(&mut reader, Endian::Big).unwrap();
+        let found = varint_decode_u64(&mut reader, Endianness::Big).unwrap();
         assert_eq!(expected_be, found);
     }
 
@@ -560,7 +566,7 @@ fn test_decode_u64() {
 
     for (slice, expected) in errors {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u64(&mut reader, Endian::Little).unwrap_err();
+        let found = varint_decode_u64(&mut reader, Endianness::Little).unwrap_err();
         assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
     }
 }
@@ -585,11 +591,11 @@ fn test_decode_u128() {
     ];
     for &(slice, expected_le, expected_be) in cases {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u128(&mut reader, Endian::Little).unwrap();
+        let found = varint_decode_u128(&mut reader, Endianness::Little).unwrap();
         assert_eq!(expected_le, found);
 
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u128(&mut reader, Endian::Big).unwrap();
+        let found = varint_decode_u128(&mut reader, Endianness::Big).unwrap();
         assert_eq!(expected_be, found);
     }
 
@@ -697,7 +703,7 @@ fn test_decode_u128() {
 
     for (slice, expected) in errors {
         let mut reader = crate::de::read::SliceReader::new(slice);
-        let found = varint_decode_u128(&mut reader, Endian::Little).unwrap_err();
+        let found = varint_decode_u128(&mut reader, Endianness::Little).unwrap_err();
         std::dbg!(slice);
         assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
     }
diff --git a/src/varint/encode_signed.rs b/src/varint/encode_signed.rs
index 0afa11c..01c54e4 100644
--- a/src/varint/encode_signed.rs
+++ b/src/varint/encode_signed.rs
@@ -1,9 +1,9 @@
 use super::{varint_encode_u128, varint_encode_u16, varint_encode_u32, varint_encode_u64};
-use crate::{config::Endian, enc::write::Writer, error::EncodeError};
+use crate::{config::Endianness, enc::write::Writer, error::EncodeError};
 
 pub fn varint_encode_i16<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: i16,
 ) -> Result<(), EncodeError> {
     varint_encode_u16(
@@ -22,7 +22,7 @@ pub fn varint_encode_i16<W: Writer>(
 
 pub fn varint_encode_i32<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: i32,
 ) -> Result<(), EncodeError> {
     varint_encode_u32(
@@ -41,7 +41,7 @@ pub fn varint_encode_i32<W: Writer>(
 
 pub fn varint_encode_i64<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: i64,
 ) -> Result<(), EncodeError> {
     varint_encode_u64(
@@ -60,7 +60,7 @@ pub fn varint_encode_i64<W: Writer>(
 
 pub fn varint_encode_i128<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: i128,
 ) -> Result<(), EncodeError> {
     varint_encode_u128(
@@ -79,7 +79,7 @@ pub fn varint_encode_i128<W: Writer>(
 
 pub fn varint_encode_isize<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: isize,
 ) -> Result<(), EncodeError> {
     // isize is being encoded as a i64
@@ -116,14 +116,14 @@ fn test_encode_i16() {
 
         // Little endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i16(&mut writer, Endian::Little, value).unwrap();
+        varint_encode_i16(&mut writer, Endianness::Little, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_le.len());
         assert_eq!(&buffer[..expected_le.len()], expected_le);
 
         // Big endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i16(&mut writer, Endian::Big, value).unwrap();
+        varint_encode_i16(&mut writer, Endianness::Big, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_be.len());
         assert_eq!(&buffer[..expected_be.len()], expected_be);
@@ -165,14 +165,14 @@ fn test_encode_i32() {
 
         // Little endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i32(&mut writer, Endian::Little, value).unwrap();
+        varint_encode_i32(&mut writer, Endianness::Little, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_le.len());
         assert_eq!(&buffer[..expected_le.len()], expected_le);
 
         // Big endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i32(&mut writer, Endian::Big, value).unwrap();
+        varint_encode_i32(&mut writer, Endianness::Big, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_be.len());
         assert_eq!(&buffer[..expected_be.len()], expected_be);
@@ -219,14 +219,14 @@ fn test_encode_i64() {
 
         // Little endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i64(&mut writer, Endian::Little, value).unwrap();
+        varint_encode_i64(&mut writer, Endianness::Little, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_le.len());
         assert_eq!(&buffer[..expected_le.len()], expected_le);
 
         // Big endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i64(&mut writer, Endian::Big, value).unwrap();
+        varint_encode_i64(&mut writer, Endianness::Big, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_be.len());
         assert_eq!(&buffer[..expected_be.len()], expected_be);
@@ -303,14 +303,14 @@ fn test_encode_i128() {
 
         // Little endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i128(&mut writer, Endian::Little, value).unwrap();
+        varint_encode_i128(&mut writer, Endianness::Little, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_le.len());
         assert_eq!(&buffer[..expected_le.len()], expected_le);
 
         // Big endian
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_i128(&mut writer, Endian::Big, value).unwrap();
+        varint_encode_i128(&mut writer, Endianness::Big, value).unwrap();
 
         assert_eq!(writer.bytes_written(), expected_be.len());
         assert_eq!(&buffer[..expected_be.len()], expected_be);
diff --git a/src/varint/encode_unsigned.rs b/src/varint/encode_unsigned.rs
index c0966e0..8024472 100644
--- a/src/varint/encode_unsigned.rs
+++ b/src/varint/encode_unsigned.rs
@@ -1,9 +1,9 @@
 use super::{SINGLE_BYTE_MAX, U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE};
-use crate::{config::Endian, enc::write::Writer, error::EncodeError};
+use crate::{config::Endianness, enc::write::Writer, error::EncodeError};
 
 pub fn varint_encode_u16<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: u16,
 ) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
@@ -11,15 +11,15 @@ pub fn varint_encode_u16<W: Writer>(
     } else {
         writer.write(&[U16_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&val.to_be_bytes()),
-            Endian::Little => writer.write(&val.to_le_bytes()),
+            Endianness::Big => writer.write(&val.to_be_bytes()),
+            Endianness::Little => writer.write(&val.to_le_bytes()),
         }
     }
 }
 
 pub fn varint_encode_u32<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: u32,
 ) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
@@ -27,21 +27,21 @@ pub fn varint_encode_u32<W: Writer>(
     } else if val <= u16::MAX as _ {
         writer.write(&[U16_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&(val as u16).to_be_bytes()),
-            Endian::Little => writer.write(&(val as u16).to_le_bytes()),
+            Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
+            Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
         }
     } else {
         writer.write(&[U32_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&val.to_be_bytes()),
-            Endian::Little => writer.write(&val.to_le_bytes()),
+            Endianness::Big => writer.write(&val.to_be_bytes()),
+            Endianness::Little => writer.write(&val.to_le_bytes()),
         }
     }
 }
 
 pub fn varint_encode_u64<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: u64,
 ) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
@@ -49,27 +49,27 @@ pub fn varint_encode_u64<W: Writer>(
     } else if val <= u16::MAX as _ {
         writer.write(&[U16_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&(val as u16).to_be_bytes()),
-            Endian::Little => writer.write(&(val as u16).to_le_bytes()),
+            Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
+            Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
         }
     } else if val <= u32::MAX as _ {
         writer.write(&[U32_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&(val as u32).to_be_bytes()),
-            Endian::Little => writer.write(&(val as u32).to_le_bytes()),
+            Endianness::Big => writer.write(&(val as u32).to_be_bytes()),
+            Endianness::Little => writer.write(&(val as u32).to_le_bytes()),
         }
     } else {
         writer.write(&[U64_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&val.to_be_bytes()),
-            Endian::Little => writer.write(&val.to_le_bytes()),
+            Endianness::Big => writer.write(&val.to_be_bytes()),
+            Endianness::Little => writer.write(&val.to_le_bytes()),
         }
     }
 }
 
 pub fn varint_encode_u128<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: u128,
 ) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
@@ -77,33 +77,33 @@ pub fn varint_encode_u128<W: Writer>(
     } else if val <= u16::MAX as _ {
         writer.write(&[U16_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&(val as u16).to_be_bytes()),
-            Endian::Little => writer.write(&(val as u16).to_le_bytes()),
+            Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
+            Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
         }
     } else if val <= u32::MAX as _ {
         writer.write(&[U32_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&(val as u32).to_be_bytes()),
-            Endian::Little => writer.write(&(val as u32).to_le_bytes()),
+            Endianness::Big => writer.write(&(val as u32).to_be_bytes()),
+            Endianness::Little => writer.write(&(val as u32).to_le_bytes()),
         }
     } else if val <= u64::MAX as _ {
         writer.write(&[U64_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&(val as u64).to_be_bytes()),
-            Endian::Little => writer.write(&(val as u64).to_le_bytes()),
+            Endianness::Big => writer.write(&(val as u64).to_be_bytes()),
+            Endianness::Little => writer.write(&(val as u64).to_le_bytes()),
         }
     } else {
         writer.write(&[U128_BYTE])?;
         match endian {
-            Endian::Big => writer.write(&val.to_be_bytes()),
-            Endian::Little => writer.write(&val.to_le_bytes()),
+            Endianness::Big => writer.write(&val.to_be_bytes()),
+            Endianness::Little => writer.write(&val.to_le_bytes()),
         }
     }
 }
 
 pub fn varint_encode_usize<W: Writer>(
     writer: &mut W,
-    endian: Endian,
+    endian: Endianness,
     val: usize,
 ) -> Result<(), EncodeError> {
     // usize is being encoded as a u64
@@ -118,13 +118,13 @@ fn test_encode_u16() {
     // these should all encode to a single byte
     for i in 0u16..=SINGLE_BYTE_MAX as u16 {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u16(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u16(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u16, i);
 
         // Assert endianness doesn't matter
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u16(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u16(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u16, i);
     }
@@ -141,13 +141,13 @@ fn test_encode_u16() {
         u16::MAX,
     ] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u16(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u16(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &i.to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u16(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u16(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &i.to_le_bytes());
@@ -162,13 +162,13 @@ fn test_encode_u32() {
     // these should all encode to a single byte
     for i in 0u32..=SINGLE_BYTE_MAX as u32 {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u32(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u32(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u32, i);
 
         // Assert endianness doesn't matter
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u32(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u32(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u32, i);
     }
@@ -185,13 +185,13 @@ fn test_encode_u32() {
         u16::MAX as u32,
     ] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u32(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u32(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u32(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u32(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes());
@@ -201,13 +201,13 @@ fn test_encode_u32() {
     // Values chosen at random, add new cases as needed
     for i in [u16::MAX as u32 + 1, 100_000, 1_000_000, u32::MAX] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u32(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u32(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 5);
         assert_eq!(buffer[0], U32_BYTE);
         assert_eq!(&buffer[1..5], &i.to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u32(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u32(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 5);
         assert_eq!(buffer[0], U32_BYTE);
         assert_eq!(&buffer[1..5], &i.to_le_bytes());
@@ -222,13 +222,13 @@ fn test_encode_u64() {
     // these should all encode to a single byte
     for i in 0u64..=SINGLE_BYTE_MAX as u64 {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u64, i);
 
         // Assert endianness doesn't matter
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u64, i);
     }
@@ -245,13 +245,13 @@ fn test_encode_u64() {
         u16::MAX as u64,
     ] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes());
@@ -261,13 +261,13 @@ fn test_encode_u64() {
     // Values chosen at random, add new cases as needed
     for i in [u16::MAX as u64 + 1, 100_000, 1_000_000, u32::MAX as u64] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 5);
         assert_eq!(buffer[0], U32_BYTE);
         assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 5);
         assert_eq!(buffer[0], U32_BYTE);
         assert_eq!(&buffer[1..5], &(i as u32).to_le_bytes());
@@ -277,13 +277,13 @@ fn test_encode_u64() {
     // Values chosen at random, add new cases as needed
     for i in [u32::MAX as u64 + 1, 5_000_000_000, u64::MAX] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 9);
         assert_eq!(buffer[0], U64_BYTE);
         assert_eq!(&buffer[1..9], &i.to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u64(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 9);
         assert_eq!(buffer[0], U64_BYTE);
         assert_eq!(&buffer[1..9], &i.to_le_bytes());
@@ -298,13 +298,13 @@ fn test_encode_u128() {
     // these should all encode to a single byte
     for i in 0u128..=SINGLE_BYTE_MAX as u128 {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u128, i);
 
         // Assert endianness doesn't matter
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 1);
         assert_eq!(buffer[0] as u128, i);
     }
@@ -321,13 +321,13 @@ fn test_encode_u128() {
         u16::MAX as u128,
     ] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 3);
         assert_eq!(buffer[0], U16_BYTE);
         assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes());
@@ -337,13 +337,13 @@ fn test_encode_u128() {
     // Values chosen at random, add new cases as needed
     for i in [u16::MAX as u128 + 1, 100_000, 1_000_000, u32::MAX as u128] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 5);
         assert_eq!(buffer[0], U32_BYTE);
         assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 5);
         assert_eq!(buffer[0], U32_BYTE);
         assert_eq!(&buffer[1..5], &(i as u32).to_le_bytes());
@@ -353,13 +353,13 @@ fn test_encode_u128() {
     // Values chosen at random, add new cases as needed
     for i in [u32::MAX as u128 + 1, 5_000_000_000, u64::MAX as u128] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 9);
         assert_eq!(buffer[0], U64_BYTE);
         assert_eq!(&buffer[1..9], &(i as u64).to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 9);
         assert_eq!(buffer[0], U64_BYTE);
         assert_eq!(&buffer[1..9], &(i as u64).to_le_bytes());
@@ -369,13 +369,13 @@ fn test_encode_u128() {
     // Values chosen at random, add new cases as needed
     for i in [u64::MAX as u128 + 1, u128::MAX] {
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Big, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
         assert_eq!(writer.bytes_written(), 17);
         assert_eq!(buffer[0], U128_BYTE);
         assert_eq!(&buffer[1..17], &i.to_be_bytes());
 
         let mut writer = SliceWriter::new(&mut buffer);
-        varint_encode_u128(&mut writer, Endian::Little, i).unwrap();
+        varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
         assert_eq!(writer.bytes_written(), 17);
         assert_eq!(buffer[0], U128_BYTE);
         assert_eq!(&buffer[1..17], &i.to_le_bytes());