diff --git a/dnp3/src/app/parse/header_identity_tests.rs b/dnp3/src/app/parse/header_identity_tests.rs
index 3fefe5194..5dc45e314 100644
--- a/dnp3/src/app/parse/header_identity_tests.rs
+++ b/dnp3/src/app/parse/header_identity_tests.rs
@@ -8,7 +8,7 @@
 
 use crate::app::attr::AttrParseError;
 use crate::app::parse::options::ParseOptions;
-use crate::app::parse::parser::{HeaderCollection, HeaderDetails};
+use crate::app::parse::parser::{HeaderCollection, ObjectHeader};
 use crate::app::{FunctionCode, ObjectParseError, QualifierCode, Variation};
 
 use ObjectParseError as E;
@@ -342,10 +342,10 @@ fn each_parsed_header_carries_its_variation_and_qualifier() {
                 let headers = HeaderCollection::parse(options, function, &bytes).unwrap();
                 let header = headers.get_only_header().unwrap();
                 assert_eq!(header.variation(), variation);
-                assert_eq!(header.details.qualifier(), qualifier);
-                assert!(!matches!(header.details, HeaderDetails::Read(..)));
+                assert_eq!(header.qualifier(), qualifier);
+                assert!(!matches!(header, ObjectHeader::Read(..)));
                 assert_eq!(
-                    header.details.count().is_some(),
+                    header.count().is_some(),
                     matches!(qualifier, Q::Count8 | Q::Count16)
                 );
             }
@@ -365,7 +365,7 @@ fn headers_in_one_fragment_each_carry_their_variation_and_qualifier() {
             let headers = HeaderCollection::parse(options, function, &fragment).unwrap();
             let actual: Vec<(Variation, QualifierCode)> = headers
                 .iter()
-                .map(|header| (header.variation(), header.details.qualifier()))
+                .map(|header| (header.variation(), header.qualifier()))
                 .collect();
             let expected: Vec<(Variation, QualifierCode)> =
                 accepted.iter().map(|(v, q, _)| (*v, *q)).collect();
@@ -386,8 +386,8 @@ fn each_read_header_carries_its_variation_and_qualifier() {
             if let Ok(headers) = parsed {
                 let header = headers.get_only_header().unwrap();
                 assert_eq!(header.variation(), variation);
-                assert_eq!(header.details.qualifier(), qualifier);
-                assert!(header.details.count().is_none());
+                assert_eq!(header.qualifier(), qualifier);
+                assert!(header.count().is_none());
                 accepted += 1;
             }
         }
diff --git a/dnp3/src/app/parse/parser.rs b/dnp3/src/app/parse/parser.rs
index 318a8bd69..490b2b8bf 100644
--- a/dnp3/src/app/parse/parser.rs
+++ b/dnp3/src/app/parse/parser.rs
@@ -158,62 +158,6 @@ impl<'a> ParsedFragment<'a> {
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct ObjectHeader<'a> {
-    pub(crate) details: HeaderDetails<'a>,
-}
-
-impl<'a> ObjectHeader<'a> {
-    pub(crate) fn new(details: HeaderDetails<'a>) -> Self {
-        Self { details }
-    }
-
-    pub(crate) fn variation(&self) -> Variation {
-        self.details.variation()
-    }
-
-    pub(crate) fn format(&self, format_values: bool, f: &mut Formatter) -> std::fmt::Result {
-        let variation = self.variation();
-        write!(
-            f,
-            "{} : {} - {}",
-            variation,
-            variation.description(),
-            self.details.qualifier().description()
-        )?;
-
-        match &self.details {
-            HeaderDetails::AllObjects(_) => return Ok(()),
-            HeaderDetails::Range(_, range, _) => {
-                write!(f, " - [{}, {}]", range.get_start(), range.get_stop())?
-            }
-            HeaderDetails::Count(_, count, _) => write!(f, " - [{count}]")?,
-            HeaderDetails::CountAndPrefix8(count, _) => write!(f, " - [{count}]")?,
-            HeaderDetails::CountAndPrefix16(count, _) => write!(f, " - [{count}]")?,
-            HeaderDetails::FreeFormat(_) => f.write_str(" - [1]")?,
-            HeaderDetails::Read(_, ReadQualifier::AllObjects) => return Ok(()),
-            HeaderDetails::Read(_, ReadQualifier::Range(_, range)) => {
-                write!(f, " - [{}, {}]", range.get_start(), range.get_stop())?
-            }
-            HeaderDetails::Read(_, ReadQualifier::Count(_, count)) => write!(f, " - [{count}]")?,
-        }
-
-        if !format_values {
-            return Ok(());
-        }
-
-        match &self.details {
-            HeaderDetails::AllObjects(_) => Ok(()),
-            HeaderDetails::Range(_, _, seq) => seq.format_objects(f),
-            HeaderDetails::Count(_, _, seq) => seq.format_objects(f),
-            HeaderDetails::CountAndPrefix8(_, seq) => seq.format_objects(f),
-            HeaderDetails::CountAndPrefix16(_, seq) => seq.format_objects(f),
-            HeaderDetails::FreeFormat(var) => var.format_objects(f),
-            HeaderDetails::Read(..) => Ok(()),
-        }
-    }
-}
-
 pub(crate) struct FragmentDisplay<'a> {
     level: AppDecodeLevel,
     fragment: ParsedFragment<'a>,
@@ -302,7 +246,7 @@ impl ReadQualifier {
 }
 
 #[derive(Debug)]
-pub(crate) enum HeaderDetails<'a> {
+pub(crate) enum ObjectHeader<'a> {
     AllObjects(AllObjectsVariation),
     Range(Width, Range, RangedVariation<'a>),
     Count(Width, u16, CountVariation<'a>),
@@ -314,37 +258,78 @@ pub(crate) enum HeaderDetails<'a> {
     Read(Variation, ReadQualifier),
 }
 
-impl HeaderDetails<'_> {
+impl ObjectHeader<'_> {
     pub(crate) fn variation(&self) -> Variation {
         match self {
-            HeaderDetails::AllObjects(objects) => objects.variation(),
-            HeaderDetails::Range(_, _, objects) => objects.variation(),
-            HeaderDetails::Count(_, _, objects) => objects.variation(),
-            HeaderDetails::CountAndPrefix8(_, objects) => objects.variation(),
-            HeaderDetails::CountAndPrefix16(_, objects) => objects.variation(),
-            HeaderDetails::FreeFormat(object) => object.variation(),
-            HeaderDetails::Read(variation, _) => *variation,
+            ObjectHeader::AllObjects(objects) => objects.variation(),
+            ObjectHeader::Range(_, _, objects) => objects.variation(),
+            ObjectHeader::Count(_, _, objects) => objects.variation(),
+            ObjectHeader::CountAndPrefix8(_, objects) => objects.variation(),
+            ObjectHeader::CountAndPrefix16(_, objects) => objects.variation(),
+            ObjectHeader::FreeFormat(object) => object.variation(),
+            ObjectHeader::Read(variation, _) => *variation,
         }
     }
 
     pub(crate) fn qualifier(&self) -> QualifierCode {
         match self {
-            HeaderDetails::AllObjects(_) => QualifierCode::AllObjects,
-            HeaderDetails::Range(width, _, _) => width.range_qualifier(),
-            HeaderDetails::Count(width, _, _) => width.count_qualifier(),
-            HeaderDetails::CountAndPrefix8(_, _) => QualifierCode::CountAndPrefix8,
-            HeaderDetails::CountAndPrefix16(_, _) => QualifierCode::CountAndPrefix16,
-            HeaderDetails::FreeFormat(_) => QualifierCode::FreeFormat16,
-            HeaderDetails::Read(_, qualifier) => qualifier.qualifier(),
+            ObjectHeader::AllObjects(_) => QualifierCode::AllObjects,
+            ObjectHeader::Range(width, _, _) => width.range_qualifier(),
+            ObjectHeader::Count(width, _, _) => width.count_qualifier(),
+            ObjectHeader::CountAndPrefix8(_, _) => QualifierCode::CountAndPrefix8,
+            ObjectHeader::CountAndPrefix16(_, _) => QualifierCode::CountAndPrefix16,
+            ObjectHeader::FreeFormat(_) => QualifierCode::FreeFormat16,
+            ObjectHeader::Read(_, qualifier) => qualifier.qualifier(),
         }
     }
 
     pub(crate) fn count(&self) -> Option<&CountVariation<'_>> {
         match self {
-            HeaderDetails::Count(_, _, objects) => Some(objects),
+            ObjectHeader::Count(_, _, objects) => Some(objects),
             _ => None,
         }
     }
+
+    pub(crate) fn format(&self, format_values: bool, f: &mut Formatter) -> std::fmt::Result {
+        let variation = self.variation();
+        write!(
+            f,
+            "{} : {} - {}",
+            variation,
+            variation.description(),
+            self.qualifier().description()
+        )?;
+
+        match self {
+            ObjectHeader::AllObjects(_) => return Ok(()),
+            ObjectHeader::Range(_, range, _) => {
+                write!(f, " - [{}, {}]", range.get_start(), range.get_stop())?
+            }
+            ObjectHeader::Count(_, count, _) => write!(f, " - [{count}]")?,
+            ObjectHeader::CountAndPrefix8(count, _) => write!(f, " - [{count}]")?,
+            ObjectHeader::CountAndPrefix16(count, _) => write!(f, " - [{count}]")?,
+            ObjectHeader::FreeFormat(_) => f.write_str(" - [1]")?,
+            ObjectHeader::Read(_, ReadQualifier::AllObjects) => return Ok(()),
+            ObjectHeader::Read(_, ReadQualifier::Range(_, range)) => {
+                write!(f, " - [{}, {}]", range.get_start(), range.get_stop())?
+            }
+            ObjectHeader::Read(_, ReadQualifier::Count(_, count)) => write!(f, " - [{count}]")?,
+        }
+
+        if !format_values {
+            return Ok(());
+        }
+
+        match self {
+            ObjectHeader::AllObjects(_) => Ok(()),
+            ObjectHeader::Range(_, _, seq) => seq.format_objects(f),
+            ObjectHeader::Count(_, _, seq) => seq.format_objects(f),
+            ObjectHeader::CountAndPrefix8(_, seq) => seq.format_objects(f),
+            ObjectHeader::CountAndPrefix16(_, seq) => seq.format_objects(f),
+            ObjectHeader::FreeFormat(var) => var.format_objects(f),
+            ObjectHeader::Read(..) => Ok(()),
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -496,16 +481,12 @@ impl<'a> ObjectParser<'a> {
             QualifierCode::Range16 => self.parse_range(gv, Width::Two),
             QualifierCode::Count8 => self.parse_count(gv, Width::One),
             QualifierCode::Count16 => self.parse_count(gv, Width::Two),
-            QualifierCode::CountAndPrefix8 => {
-                self.parse_count_and_prefix(gv).map(|(count, data)| {
-                    ObjectHeader::new(HeaderDetails::CountAndPrefix8(count, data))
-                })
-            }
-            QualifierCode::CountAndPrefix16 => {
-                self.parse_count_and_prefix(gv).map(|(count, data)| {
-                    ObjectHeader::new(HeaderDetails::CountAndPrefix16(count, data))
-                })
-            }
+            QualifierCode::CountAndPrefix8 => self
+                .parse_count_and_prefix(gv)
+                .map(|(count, data)| ObjectHeader::CountAndPrefix8(count, data)),
+            QualifierCode::CountAndPrefix16 => self
+                .parse_count_and_prefix(gv)
+                .map(|(count, data)| ObjectHeader::CountAndPrefix16(count, data)),
             QualifierCode::FreeFormat16 => self.parse_free_format_u16(gv),
         }
     }
@@ -515,7 +496,7 @@ impl<'a> ObjectParser<'a> {
         qualifier: ReadQualifier,
     ) -> Result<ObjectHeader<'a>, ObjectParseError> {
         if qualifier.accepts(v) {
-            Ok(ObjectHeader::new(HeaderDetails::Read(v, qualifier)))
+            Ok(ObjectHeader::Read(v, qualifier))
         } else {
             Err(ObjectParseError::InvalidQualifierForVariation(
                 v,
@@ -529,7 +510,7 @@ impl<'a> ObjectParser<'a> {
             return Self::parse_read(v, ReadQualifier::AllObjects);
         }
         match AllObjectsVariation::get(v) {
-            Some(av) => Ok(ObjectHeader::new(HeaderDetails::AllObjects(av))),
+            Some(av) => Ok(ObjectHeader::AllObjects(av)),
             None => Err(ObjectParseError::InvalidQualifierForVariation(
                 v,
                 QualifierCode::AllObjects,
@@ -548,7 +529,7 @@ impl<'a> ObjectParser<'a> {
         }
         let data =
             CountVariation::parse_non_read(v, width.count_qualifier(), count, &mut self.cursor)?;
-        Ok(ObjectHeader::new(HeaderDetails::Count(width, count, data)))
+        Ok(ObjectHeader::Count(width, count, data))
     }
 
     fn parse_range(
@@ -569,7 +550,7 @@ impl<'a> ObjectParser<'a> {
             self.options,
             &mut self.cursor,
         )?;
-        Ok(ObjectHeader::new(HeaderDetails::Range(width, range, data)))
+        Ok(ObjectHeader::Range(width, range, data))
     }
 
     /// the count, whose width is the prefix's, and the prefixed objects
@@ -607,7 +588,7 @@ impl<'a> ObjectParser<'a> {
         // all of the designated data must be consumed otherwise the encoding is invalid
         cursor.expect_empty()?;
 
-        Ok(ObjectHeader::new(HeaderDetails::FreeFormat(variation)))
+        Ok(ObjectHeader::FreeFormat(variation))
     }
 }
 
@@ -769,10 +750,7 @@ mod test {
             ]
         );
         for header in headers {
-            assert_matches!(
-                header.details,
-                HeaderDetails::Read(_, ReadQualifier::AllObjects)
-            );
+            assert_matches!(header, ObjectHeader::Read(_, ReadQualifier::AllObjects));
         }
     }
 
@@ -782,8 +760,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Operate, header);
 
         let items: Vec<Prefix<u8, Group41Var1>> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::CountAndPrefix8(1, PrefixedVariation::<u8>::Group41Var1(seq)) => seq.iter().collect()
+            headers.next().unwrap(),
+            ObjectHeader::CountAndPrefix8(1, PrefixedVariation::<u8>::Group41Var1(seq)) => seq.iter().collect()
         );
 
         assert_eq!(
@@ -805,8 +783,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Response, header);
 
         let items: Vec<(DoubleBit, u16)> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::Range(Width::One, range, RangedVariation::Group3Var1(seq)) if range == Range::from(1, 4).unwrap() => seq.iter().collect()
+            headers.next().unwrap(),
+            ObjectHeader::Range(Width::One, range, RangedVariation::Group3Var1(seq)) if range == Range::from(1, 4).unwrap() => seq.iter().collect()
         );
 
         assert_eq!(
@@ -827,8 +805,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Write, header);
 
         let items: Vec<Group50Var1> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::Count(Width::One, 1, CountVariation::Group50Var1(seq)) => seq.iter().collect()
+            headers.next().unwrap(),
+            ObjectHeader::Count(Width::One, 1, CountVariation::Group50Var1(seq)) => seq.iter().collect()
         );
 
         assert_eq!(
@@ -848,8 +826,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Response, &input);
 
         let items: Vec<(Group1Var2, u16)> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::Range(Width::One, range, RangedVariation::Group1Var2(seq)) if range == Range::from(2, 3).unwrap() => seq.iter().collect()
+            headers.next().unwrap(),
+            ObjectHeader::Range(Width::One, range, RangedVariation::Group1Var2(seq)) if range == Range::from(2, 3).unwrap() => seq.iter().collect()
         );
 
         assert_eq!(
@@ -871,15 +849,15 @@ mod test {
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group1Var2);
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(2, 3).unwrap()
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(2, 3).unwrap()
         );
 
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group1Var2);
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(7, 9).unwrap()
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(7, 9).unwrap()
         );
 
         assert_matches!(headers.next(), None);
@@ -892,8 +870,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Write, &input);
 
         assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::CountAndPrefix8(1, PrefixedVariation::Group34Var1(seq)) => {
+            headers.next().unwrap(),
+            ObjectHeader::CountAndPrefix8(1, PrefixedVariation::Group34Var1(seq)) => {
                 let prefix = seq.single().unwrap();
                 assert_eq!(prefix, Prefix { index: 0x03, value: Group34Var1 { value: 0xFECA }});
             }
@@ -909,8 +887,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Write, &input);
 
         let vec: Vec<(bool, u16)> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::Range(Width::One, range, RangedVariation::Group80Var1(seq)) if range == Range::from(7, 7).unwrap() => {
+            headers.next().unwrap(),
+            ObjectHeader::Range(Width::One, range, RangedVariation::Group80Var1(seq)) if range == Range::from(7, 7).unwrap() => {
                 seq.iter().collect()
             }
         );
@@ -926,11 +904,11 @@ mod test {
         ];
         let mut headers = parse_objects(FunctionCode::Write, &input);
 
-        let received = match headers.next().unwrap().details {
-            HeaderDetails::Count(Width::One, 1, CountVariation::Group50Var2(seq)) => {
+        let received = match headers.next().unwrap() {
+            ObjectHeader::Count(Width::One, 1, CountVariation::Group50Var2(seq)) => {
                 seq.single().unwrap()
             }
-            _ => panic!("unexpected header details"),
+            _ => panic!("unexpected header"),
         };
 
         assert!(headers.next().is_none());
@@ -950,8 +928,8 @@ mod test {
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group110(0));
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(2, 3).unwrap()
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(2, 3).unwrap()
         );
         assert_matches!(headers.next(), None);
     }
@@ -962,8 +940,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Response, &input);
 
         let bytes: Vec<(&[u8], u16)> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::Range(Width::One, range, RangedVariation::Group110VarX(0x01, seq)) if range == Range::from(1, 2).unwrap() => {
+            headers.next().unwrap(),
+            ObjectHeader::Range(Width::One, range, RangedVariation::Group110VarX(0x01, seq)) if range == Range::from(1, 2).unwrap() => {
                 seq.iter().collect()
             }
         );
@@ -978,8 +956,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Response, &input);
 
         let bytes: Vec<(&[u8], u16)> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::Range(Width::Two, range, RangedVariation::Group110VarX(0x01, seq)) if range == Range::from(0xFFFF, 0xFFFF).unwrap() => {
+            headers.next().unwrap(),
+            ObjectHeader::Range(Width::Two, range, RangedVariation::Group110VarX(0x01, seq)) if range == Range::from(0xFFFF, 0xFFFF).unwrap() => {
                 seq.iter().collect()
             }
         );
@@ -996,8 +974,8 @@ mod test {
         let mut headers = parse_objects(FunctionCode::Response, &input);
 
         let bytes: Vec<(&[u8], u16)> = assert_matches!(
-            headers.next().unwrap().details,
-            HeaderDetails::CountAndPrefix16(0x02, PrefixedVariation::Group111VarX(0x01, seq)) => {
+            headers.next().unwrap(),
+            ObjectHeader::CountAndPrefix16(0x02, PrefixedVariation::Group111VarX(0x01, seq)) => {
                 seq.iter().collect()
             }
         );
@@ -1020,8 +998,8 @@ mod test {
         .iter();
         let first = headers.next().unwrap();
         assert!(headers.next().is_none());
-        match first.details {
-            HeaderDetails::Range(Width::One, range, RangedVariation::Group110VarX(0, seq))
+        match first {
+            ObjectHeader::Range(Width::One, range, RangedVariation::Group110VarX(0, seq))
                 if range == Range::from(7, 7).unwrap() =>
             {
                 let mut iter = seq.iter();
@@ -1030,7 +1008,7 @@ mod test {
                 assert_eq!(first, (empty, 7));
                 assert_eq!(iter.next(), None);
             }
-            _ => panic!("unexpected header details"),
+            _ => panic!("unexpected header"),
         }
     }
 
@@ -1044,13 +1022,13 @@ mod test {
         assert!(headers.next().is_none());
 
         assert_eq!(first.variation(), Variation::Group0(0xCA));
-        let set = match first.details {
-            HeaderDetails::Range(Width::One, range, RangedVariation::Group0(set))
+        let set = match first {
+            ObjectHeader::Range(Width::One, range, RangedVariation::Group0(set))
                 if range == Range::from(0x07, 0x07).unwrap() =>
             {
                 set
             }
-            _ => panic!("unexpected header details"),
+            _ => panic!("unexpected header"),
         };
 
         assert_eq!(
@@ -1074,8 +1052,8 @@ mod test {
 
         assert_eq!(first.variation(), Variation::Group0(0xCA));
         assert!(std::matches!(
-            first.details,
-            HeaderDetails::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(0x07, 0x07).unwrap()
+            first,
+            ObjectHeader::Read(_, ReadQualifier::Range(Width::One, range)) if range == Range::from(0x07, 0x07).unwrap()
         ));
     }
 
@@ -1102,9 +1080,9 @@ mod test {
         let header = headers.iter().next().unwrap();
 
         assert_eq!(header.variation(), Variation::Group70Var5);
-        let obj = match header.details {
-            HeaderDetails::FreeFormat(FreeFormatVariation::Group70Var5(obj)) => obj,
-            _ => panic!("unexpected header details"),
+        let obj = match header {
+            ObjectHeader::FreeFormat(FreeFormatVariation::Group70Var5(obj)) => obj,
+            _ => panic!("unexpected header"),
         };
         assert_eq!(
             obj,
@@ -1122,8 +1100,8 @@ mod test {
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group50Var1);
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Count(Width::One, 1))
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Count(Width::One, 1))
         );
         assert_matches!(headers.next(), None);
 
@@ -1131,8 +1109,8 @@ mod test {
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group50Var1);
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Count(Width::Two, 1))
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Count(Width::Two, 1))
         );
         assert_matches!(headers.next(), None);
     }
@@ -1144,21 +1122,15 @@ mod test {
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group50Var1);
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Count(Width::One, 1))
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Count(Width::One, 1))
         );
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group60Var2);
-        assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::AllObjects)
-        );
+        assert_matches!(header, ObjectHeader::Read(_, ReadQualifier::AllObjects));
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group60Var3);
-        assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::AllObjects)
-        );
+        assert_matches!(header, ObjectHeader::Read(_, ReadQualifier::AllObjects));
         assert_matches!(headers.next(), None);
     }
 
@@ -1207,20 +1179,20 @@ mod test {
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group2Var1);
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Count(Width::One, 5))
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Count(Width::One, 5))
         );
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group32Var2);
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Count(Width::Two, 10))
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Count(Width::Two, 10))
         );
         let header = headers.next().unwrap();
         assert_eq!(header.variation(), Variation::Group111(1));
         assert_matches!(
-            header.details,
-            HeaderDetails::Read(_, ReadQualifier::Count(Width::One, 1))
+            header,
+            ObjectHeader::Read(_, ReadQualifier::Count(Width::One, 1))
         );
         assert_matches!(headers.next(), None);
     }
@@ -1266,8 +1238,8 @@ mod test {
             let header = headers.get_only_header().unwrap();
             assert_eq!(header.variation(), v);
             assert_matches!(
-                header.details,
-                HeaderDetails::Read(_, ReadQualifier::Count(w, 1)) if w == width
+                header,
+                ObjectHeader::Read(_, ReadQualifier::Count(w, 1)) if w == width
             );
         }
     }
diff --git a/dnp3/src/master/extract.rs b/dnp3/src/master/extract.rs
index 8c96d27ab..083e45d62 100644
--- a/dnp3/src/master/extract.rs
+++ b/dnp3/src/master/extract.rs
@@ -1,7 +1,7 @@
 use crate::app::gen::count::CountVariation;
 use crate::app::measurement::*;
 use crate::app::parse::count::CountSequence;
-use crate::app::parse::parser::{HeaderCollection, HeaderDetails, ObjectHeader};
+use crate::app::parse::parser::{HeaderCollection, ObjectHeader};
 use crate::app::variations::*;
 use crate::app::{ObjectParseError, ResponseHeader};
 use crate::master::{HeaderInfo, ReadHandler};
@@ -33,13 +33,13 @@ pub(crate) fn extract_measurements_inner(
     let mut cto = None;
     for header in objects.iter() {
         match extract_header(&header, cto, handler) {
-            Extracted::Handled => delivered |= has_objects(&header.details),
+            Extracted::Handled => delivered |= has_objects(&header),
             Extracted::Cto(x) => cto = x,
             Extracted::Ignored => {
                 tracing::warn!(
                     "ignored header variation: {} qualifier: {:?}",
                     &header.variation(),
-                    &header.details.qualifier()
+                    &header.qualifier()
                 );
             }
         }
@@ -48,14 +48,14 @@ pub(crate) fn extract_measurements_inner(
 }
 
 /// True if the header carries at least one object
-fn has_objects(details: &HeaderDetails) -> bool {
-    match details {
-        HeaderDetails::AllObjects(_) | HeaderDetails::Read(..) => false,
+fn has_objects(header: &ObjectHeader) -> bool {
+    match header {
+        ObjectHeader::AllObjects(_) | ObjectHeader::Read(..) => false,
         // a range covers at least one index, and a free-format header holds one object
-        HeaderDetails::Range(..) | HeaderDetails::FreeFormat(_) => true,
-        HeaderDetails::Count(_, count, _) => *count > 0,
-        HeaderDetails::CountAndPrefix8(count, _) => *count > 0,
-        HeaderDetails::CountAndPrefix16(count, _) => *count > 0,
+        ObjectHeader::Range(..) | ObjectHeader::FreeFormat(_) => true,
+        ObjectHeader::Count(_, count, _) => *count > 0,
+        ObjectHeader::CountAndPrefix8(count, _) => *count > 0,
+        ObjectHeader::CountAndPrefix16(count, _) => *count > 0,
     }
 }
 
@@ -99,7 +99,7 @@ pub(crate) fn validate_response(
     let objects = objects.map_err(InvalidResponse::Malformed)?;
     let mut cto = None;
     for header in objects.iter() {
-        if let Some(next) = next_cto(&header.details, cto) {
+        if let Some(next) = next_cto(&header, cto) {
             cto = next;
         } else if cto.is_none() && has_relative_time(&header) {
             return Err(InvalidResponse::RelativeTimeWithoutCto(header.variation()));
@@ -113,16 +113,16 @@ fn has_relative_time(header: &ObjectHeader) -> bool {
     matches!(
         header.variation(),
         Variation::Group2Var3 | Variation::Group4Var3
-    ) && has_objects(&header.details)
+    ) && has_objects(header)
 }
 
 /// If the header is a common time of occurrence, the one for the headers that follow it
-fn next_cto(details: &HeaderDetails, prev: Option<Time>) -> Option<Option<Time>> {
-    let time = match details {
-        HeaderDetails::Count(_, 1, CountVariation::Group51Var1(seq)) => {
+fn next_cto(header: &ObjectHeader, prev: Option<Time>) -> Option<Option<Time>> {
+    let time = match header {
+        ObjectHeader::Count(_, 1, CountVariation::Group51Var1(seq)) => {
             seq.single().map(|x| Time::Synchronized(x.time))
         }
-        HeaderDetails::Count(_, 1, CountVariation::Group51Var2(seq)) => {
+        ObjectHeader::Count(_, 1, CountVariation::Group51Var2(seq)) => {
             seq.single().map(|x| Time::Unsynchronized(x.time))
         }
         _ => return None,
@@ -154,7 +154,7 @@ pub(crate) fn extract_header<H: ReadHandler + ?Sized>(
     ) -> bool {
         if let Some(item) = seq.single() {
             handler.handle_abs_time(
-                HeaderInfo::new(header.variation(), header.details.qualifier(), false, false),
+                HeaderInfo::new(header.variation(), header.qualifier(), false, false),
                 item.time,
             );
             true
@@ -163,25 +163,23 @@ pub(crate) fn extract_header<H: ReadHandler + ?Sized>(
         }
     }
 
-    if let Some(cto) = next_cto(&header.details, cto) {
+    if let Some(cto) = next_cto(header, cto) {
         return Extracted::Cto(cto);
     }
 
-    let handled = match &header.details {
+    let handled = match &header {
         // handle g50v1 - absolute time (only count == 1 is valid)
-        HeaderDetails::Count(_, 1, CountVariation::Group50Var1(seq)) => {
+        ObjectHeader::Count(_, 1, CountVariation::Group50Var1(seq)) => {
             extract_g50v1(seq, header, handler)
         }
         // everything else
-        HeaderDetails::Range(_, _, var) => {
-            var.extract_measurements_to(header.details.qualifier(), handler)
-        }
-        HeaderDetails::CountAndPrefix8(_, var) => var.extract_measurements_to(cto, handler),
-        HeaderDetails::CountAndPrefix16(_, var) => var.extract_measurements_to(cto, handler),
-        HeaderDetails::AllObjects(_)
-        | HeaderDetails::Count(..)
-        | HeaderDetails::FreeFormat(_)
-        | HeaderDetails::Read(..) => false,
+        ObjectHeader::Range(_, _, var) => var.extract_measurements_to(header.qualifier(), handler),
+        ObjectHeader::CountAndPrefix8(_, var) => var.extract_measurements_to(cto, handler),
+        ObjectHeader::CountAndPrefix16(_, var) => var.extract_measurements_to(cto, handler),
+        ObjectHeader::AllObjects(_)
+        | ObjectHeader::Count(..)
+        | ObjectHeader::FreeFormat(_)
+        | ObjectHeader::Read(..) => false,
     };
 
     if handled {
diff --git a/dnp3/src/master/request.rs b/dnp3/src/master/request.rs
index bbc3cd9a3..bc6c486f3 100644
--- a/dnp3/src/master/request.rs
+++ b/dnp3/src/master/request.rs
@@ -5,7 +5,7 @@ use crate::app::control::CommandStatus;
 use crate::app::format::write::HeaderWriter;
 use crate::app::gen::prefixed::PrefixedVariation;
 use crate::app::parse::count::CountSequence;
-use crate::app::parse::parser::{HeaderCollection, HeaderDetails};
+use crate::app::parse::parser::{HeaderCollection, ObjectHeader};
 use crate::app::parse::prefix::Prefix;
 use crate::app::parse::traits::Index;
 use crate::app::variations::*;
@@ -785,7 +785,7 @@ impl CommandHeaders {
         for sent in &self.headers {
             match iter.next() {
                 None => return Err(CommandResponseError::HeaderCountMismatch),
-                Some(received) => sent.compare(received.details)?,
+                Some(received) => sent.compare(received)?,
             }
         }
 
@@ -979,12 +979,12 @@ impl CommandHeader {
         }
     }
 
-    pub(crate) fn compare(&self, response: HeaderDetails) -> Result<(), CommandResponseError> {
+    pub(crate) fn compare(&self, response: ObjectHeader) -> Result<(), CommandResponseError> {
         match (self, response) {
-            (CommandHeader::U8(items), HeaderDetails::CountAndPrefix8(_, objects)) => {
+            (CommandHeader::U8(items), ObjectHeader::CountAndPrefix8(_, objects)) => {
                 items.compare(objects)
             }
-            (CommandHeader::U16(items), HeaderDetails::CountAndPrefix16(_, objects)) => {
+            (CommandHeader::U16(items), ObjectHeader::CountAndPrefix16(_, objects)) => {
                 items.compare(objects)
             }
             _ => Err(CommandResponseError::HeaderTypeMismatch),
diff --git a/dnp3/src/master/tasks/file/get_info.rs b/dnp3/src/master/tasks/file/get_info.rs
index 497bc4dd5..9f6f2d358 100644
--- a/dnp3/src/master/tasks/file/get_info.rs
+++ b/dnp3/src/master/tasks/file/get_info.rs
@@ -1,7 +1,7 @@
 use crate::app::file::*;
 use crate::app::format::write::HeaderWriter;
 use crate::app::parse::free_format::FreeFormatVariation;
-use crate::app::parse::parser::{HeaderDetails, Response};
+use crate::app::parse::parser::{ObjectHeader, Response};
 use crate::app::{FunctionCode, Timestamp};
 use crate::master::tasks::{NonReadTask, OneShot, OneShotRequest};
 use crate::master::{FileError, FileInfo, TaskError, TaskType};
@@ -43,9 +43,9 @@ impl OneShotRequest for GetFileInfoRequest {
     fn parse(&self, response: Response<'_>) -> Result<FileInfo, FileError> {
         let header = response.objects?.get_only_header()?;
 
-        match header.details {
-            HeaderDetails::FreeFormat(FreeFormatVariation::Group70Var7(obj)) => Ok(obj.into()),
-            HeaderDetails::FreeFormat(FreeFormatVariation::Group70Var4(obj)) => {
+        match header {
+            ObjectHeader::FreeFormat(FreeFormatVariation::Group70Var7(obj)) => Ok(obj.into()),
+            ObjectHeader::FreeFormat(FreeFormatVariation::Group70Var4(obj)) => {
                 if obj.status_code != FileStatus::Success {
                     tracing::warn!("Unable to get file info: {}", obj.text);
                 }
diff --git a/dnp3/src/master/tasks/file/mod.rs b/dnp3/src/master/tasks/file/mod.rs
index d4da8e7cf..c11052cf8 100644
--- a/dnp3/src/master/tasks/file/mod.rs
+++ b/dnp3/src/master/tasks/file/mod.rs
@@ -1,7 +1,7 @@
 use crate::app::format::write::HeaderWriter;
 use crate::app::format::WriteError;
 use crate::app::parse::free_format::FreeFormatVariation;
-use crate::app::parse::parser::{HeaderDetails, ObjectHeader};
+use crate::app::parse::parser::ObjectHeader;
 use crate::app::{FileStatus, Group70Var2, Group70Var3, Group70Var4, Permissions, Timestamp};
 use crate::master::{AuthKey, FileCredentials, FileError, FileHandle, FileMode, OpenFile};
 
@@ -66,8 +66,8 @@ pub(super) fn write_close(handle: FileHandle, writer: &mut HeaderWriter) -> Resu
 }
 
 pub(super) fn parse_auth_response(header: ObjectHeader) -> Result<AuthKey, FileError> {
-    let obj = match header.details {
-        HeaderDetails::FreeFormat(FreeFormatVariation::Group70Var2(obj)) => obj,
+    let obj = match header {
+        ObjectHeader::FreeFormat(FreeFormatVariation::Group70Var2(obj)) => obj,
         _ => {
             tracing::warn!(
                 "File AUTHENTICATE response contains unexpected variation: {}",
@@ -132,8 +132,8 @@ fn parse_status_object<'a>(
     header: ObjectHeader<'a>,
     function: &str,
 ) -> Result<Group70Var4<'a>, FileError> {
-    match header.details {
-        HeaderDetails::FreeFormat(FreeFormatVariation::Group70Var4(obj)) => Ok(obj),
+    match header {
+        ObjectHeader::FreeFormat(FreeFormatVariation::Group70Var4(obj)) => Ok(obj),
         _ => {
             tracing::warn!(
                 "File {function} response contains unexpected variation: {}",
diff --git a/dnp3/src/master/tasks/file/read.rs b/dnp3/src/master/tasks/file/read.rs
index feaddf451..47b5f3473 100644
--- a/dnp3/src/master/tasks/file/read.rs
+++ b/dnp3/src/master/tasks/file/read.rs
@@ -138,8 +138,8 @@ impl FileReadTask {
         rs: ReadState,
         header: ObjectHeader<'_>,
     ) -> Result<Option<ReadState>, FileError> {
-        let obj = match header.details {
-            HeaderDetails::FreeFormat(FreeFormatVariation::Group70Var5(obj)) => obj,
+        let obj = match header {
+            ObjectHeader::FreeFormat(FreeFormatVariation::Group70Var5(obj)) => obj,
             _ => {
                 tracing::warn!(
                     "File READ response contains unexpected variation: {}",
diff --git a/dnp3/src/master/tasks/file/write_block.rs b/dnp3/src/master/tasks/file/write_block.rs
index 887aa1396..b5ddf25cb 100644
--- a/dnp3/src/master/tasks/file/write_block.rs
+++ b/dnp3/src/master/tasks/file/write_block.rs
@@ -1,6 +1,6 @@
 use crate::app::format::write::HeaderWriter;
 use crate::app::parse::free_format::FreeFormatVariation;
-use crate::app::parse::parser::{HeaderDetails, Response};
+use crate::app::parse::parser::{ObjectHeader, Response};
 use crate::app::{FileStatus, FunctionCode, Group70Var5};
 use crate::master::tasks::{NonReadTask, OneShot, OneShotRequest};
 use crate::master::{BlockNumber, FileError, FileHandle, TaskError, TaskType};
@@ -36,8 +36,8 @@ impl OneShotRequest for WriteBlockRequest {
     fn parse(&self, response: Response<'_>) -> Result<(), FileError> {
         let header = response.objects?.get_only_header()?;
 
-        let obj = match header.details {
-            HeaderDetails::FreeFormat(FreeFormatVariation::Group70Var6(obj)) => obj,
+        let obj = match header {
+            ObjectHeader::FreeFormat(FreeFormatVariation::Group70Var6(obj)) => obj,
             _ => {
                 tracing::warn!(
                     "File WRITE response contains unexpected variation: {}",
diff --git a/dnp3/src/master/tasks/restart.rs b/dnp3/src/master/tasks/restart.rs
index d78336b53..8f7033d6a 100644
--- a/dnp3/src/master/tasks/restart.rs
+++ b/dnp3/src/master/tasks/restart.rs
@@ -43,10 +43,7 @@ impl OneShotRequest for RestartType {
     fn parse(&self, response: Response<'_>) -> Result<Duration, TaskError> {
         let header = response.get_only_object_header()?;
 
-        let count = header
-            .details
-            .count()
-            .ok_or(TaskError::UnexpectedResponseHeaders)?;
+        let count = header.count().ok_or(TaskError::UnexpectedResponseHeaders)?;
 
         match count {
             CountVariation::Group52Var1(val) => match val.single() {
diff --git a/dnp3/src/master/tasks/time.rs b/dnp3/src/master/tasks/time.rs
index 0c9a8999e..9564485c2 100644
--- a/dnp3/src/master/tasks/time.rs
+++ b/dnp3/src/master/tasks/time.rs
@@ -166,12 +166,11 @@ impl TimeSyncTask {
 
         let header = response.get_only_object_header().map_err(TaskError::from)?;
 
-        let delay_ms: Option<u16> =
-            if let Some(CountVariation::Group52Var2(seq)) = header.details.count() {
-                seq.single().map(|x| x.time)
-            } else {
-                None
-            };
+        let delay_ms: Option<u16> = if let Some(CountVariation::Group52Var2(seq)) = header.count() {
+            seq.single().map(|x| x.time)
+        } else {
+            None
+        };
 
         let delay_ms = match delay_ms {
             Some(x) => x,
@@ -648,7 +647,7 @@ mod tests {
 
             assert_eq!(request.header.function, FunctionCode::Write);
             let header = request.objects.unwrap().get_only_header().unwrap();
-            match header.details.count().unwrap() {
+            match header.count().unwrap() {
                 CountVariation::Group50Var1(seq) => {
                     assert_eq!(
                         seq.single().unwrap().time,
@@ -789,7 +788,7 @@ mod tests {
 
             assert_eq!(request.header.function, FunctionCode::Write);
             let header = request.objects.unwrap().get_only_header().unwrap();
-            match header.details.count().unwrap() {
+            match header.count().unwrap() {
                 CountVariation::Group50Var3(seq) => {
                     assert_eq!(seq.single().unwrap().time, system_time);
                 }
@@ -824,7 +823,7 @@ mod tests {
             let request = writer.to_parsed().to_request().unwrap();
 
             let header = request.objects.unwrap().get_only_header().unwrap();
-            match header.details.count().unwrap() {
+            match header.count().unwrap() {
                 CountVariation::Group50Var1(seq) => {
                     assert_eq!(seq.single().unwrap().time, system_time);
                 }
diff --git a/dnp3/src/outstation/control/collection.rs b/dnp3/src/outstation/control/collection.rs
index f8bb09dbf..aa6de397c 100644
--- a/dnp3/src/outstation/control/collection.rs
+++ b/dnp3/src/outstation/control/collection.rs
@@ -1,7 +1,7 @@
 use crate::app::control::*;
 use crate::app::gen::prefixed::PrefixedVariation;
 use crate::app::parse::count::CountSequence;
-use crate::app::parse::parser::{HeaderCollection, HeaderDetails, HeaderIterator, ObjectHeader};
+use crate::app::parse::parser::{HeaderCollection, HeaderIterator, ObjectHeader};
 use crate::app::parse::prefix::Prefix;
 use crate::app::parse::traits::Index;
 use crate::app::{QualifierCode, Variation};
@@ -97,17 +97,17 @@ pub(crate) enum ControlMode {
 
 impl<'a> ObjectHeader<'a> {
     pub(crate) fn to_control_header(&self) -> Result<ControlHeader<'a>, BadControlHeader> {
-        let header = match &self.details {
-            HeaderDetails::CountAndPrefix8(_, objects) => {
+        let header = match self {
+            ObjectHeader::CountAndPrefix8(_, objects) => {
                 ControlObjects::new(objects).map(ControlHeader::OneByte)
             }
-            HeaderDetails::CountAndPrefix16(_, objects) => {
+            ObjectHeader::CountAndPrefix16(_, objects) => {
                 ControlObjects::new(objects).map(ControlHeader::TwoByte)
             }
             _ => None,
         };
 
-        header.ok_or_else(|| BadControlHeader::new(self.variation(), self.details.qualifier()))
+        header.ok_or_else(|| BadControlHeader::new(self.variation(), self.qualifier()))
     }
 }
 
diff --git a/dnp3/src/outstation/database/read.rs b/dnp3/src/outstation/database/read.rs
index 698f1a260..572900b83 100644
--- a/dnp3/src/outstation/database/read.rs
+++ b/dnp3/src/outstation/database/read.rs
@@ -1,4 +1,4 @@
-use crate::app::parse::parser::{HeaderDetails, ObjectHeader, ReadQualifier};
+use crate::app::parse::parser::{ObjectHeader, ReadQualifier};
 use crate::app::parse::range::Range;
 use crate::app::{Iin2, Variation};
 use crate::outstation::database::config::*;
@@ -76,20 +76,20 @@ impl ReadHeader {
     /// any other is an unsupported object
     pub(crate) fn parse(header: &ObjectHeader) -> Result<ReadHeader, Iin2> {
         let target = ReadTarget::get(header.variation());
-        let res = match header.details {
-            HeaderDetails::Read(_, qualifier) => target.and_then(|x| x.with(qualifier)),
-            HeaderDetails::AllObjects(_)
-            | HeaderDetails::Range(_, _, _)
-            | HeaderDetails::Count(_, _, _)
-            | HeaderDetails::CountAndPrefix8(_, _)
-            | HeaderDetails::CountAndPrefix16(_, _)
-            | HeaderDetails::FreeFormat(_) => None,
+        let res = match *header {
+            ObjectHeader::Read(_, qualifier) => target.and_then(|x| x.with(qualifier)),
+            ObjectHeader::AllObjects(_)
+            | ObjectHeader::Range(_, _, _)
+            | ObjectHeader::Count(_, _, _)
+            | ObjectHeader::CountAndPrefix8(_, _)
+            | ObjectHeader::CountAndPrefix16(_, _)
+            | ObjectHeader::FreeFormat(_) => None,
         };
         res.ok_or_else(|| {
             tracing::warn!(
                 "{} - {} not supported in READ requests",
                 header.variation(),
-                header.details.qualifier()
+                header.qualifier()
             );
             if target.is_some() {
                 Iin2::PARAMETER_ERROR
diff --git a/dnp3/src/outstation/deferred.rs b/dnp3/src/outstation/deferred.rs
index 51a746174..af57e34c0 100644
--- a/dnp3/src/outstation/deferred.rs
+++ b/dnp3/src/outstation/deferred.rs
@@ -70,7 +70,7 @@ impl DeferredRead {
                             "insufficient capacity ({}) for READ header: {} - {}",
                             self.headers.max(),
                             h.variation(),
-                            h.details.qualifier()
+                            h.qualifier()
                         );
                         iin2 |= Iin2::PARAMETER_ERROR;
                     }
diff --git a/dnp3/src/outstation/session.rs b/dnp3/src/outstation/session.rs
index 0ef6ea9d2..0e59dadd9 100644
--- a/dnp3/src/outstation/session.rs
+++ b/dnp3/src/outstation/session.rs
@@ -9,7 +9,7 @@ use crate::app::format::write::HeaderWriter;
 use crate::app::gen::count::CountVariation;
 use crate::app::gen::ranged::RangedVariation;
 use crate::app::parse::count::CountSequence;
-use crate::app::parse::parser::{HeaderCollection, HeaderDetails, ObjectHeader, Request};
+use crate::app::parse::parser::{HeaderCollection, ObjectHeader, Request};
 use crate::app::parse::range::RangedSequence;
 use crate::app::variations::{
     Group34Var1, Group34Var2, Group34Var3, Group50Var1, Group50Var3, Group52Var1, Group52Var2,
@@ -1621,51 +1621,51 @@ impl OutstationSession {
         header: ObjectHeader<'_>,
         db: &DatabaseHandle,
     ) -> Iin2 {
-        match header.details {
-            HeaderDetails::Range(_, _, RangedVariation::Group0(attr)) => {
+        match header {
+            ObjectHeader::Range(_, _, RangedVariation::Group0(attr)) => {
                 self.handle_write_attr(attr, db).await
             }
-            HeaderDetails::Range(_, _, RangedVariation::Group80Var1(bits)) => {
+            ObjectHeader::Range(_, _, RangedVariation::Group80Var1(bits)) => {
                 self.handle_write_iin(bits)
             }
-            HeaderDetails::Count(_, _, CountVariation::Group50Var1(seq)) => {
+            ObjectHeader::Count(_, _, CountVariation::Group50Var1(seq)) => {
                 self.handle_write_abs_time(seq)
             }
-            HeaderDetails::Count(_, _, CountVariation::Group50Var3(seq)) => {
+            ObjectHeader::Count(_, _, CountVariation::Group50Var3(seq)) => {
                 self.handle_write_at_last_recorded_time(seq)
             }
             // analog deadbands
-            HeaderDetails::Range(_, _, RangedVariation::Group34Var1(seq)) => {
+            ObjectHeader::Range(_, _, RangedVariation::Group34Var1(seq)) => {
                 self.handle_write_ranged_analog_deadbands(seq, db).await
             }
-            HeaderDetails::Range(_, _, RangedVariation::Group34Var2(seq)) => {
+            ObjectHeader::Range(_, _, RangedVariation::Group34Var2(seq)) => {
                 self.handle_write_ranged_analog_deadbands(seq, db).await
             }
-            HeaderDetails::Range(_, _, RangedVariation::Group34Var3(seq)) => {
+            ObjectHeader::Range(_, _, RangedVariation::Group34Var3(seq)) => {
                 self.handle_write_ranged_analog_deadbands(seq, db).await
             }
-            HeaderDetails::CountAndPrefix8(_, PrefixedVariation::Group34Var1(seq)) => {
+            ObjectHeader::CountAndPrefix8(_, PrefixedVariation::Group34Var1(seq)) => {
                 self.handle_write_prefixed_analog_deadbands(seq, db).await
             }
-            HeaderDetails::CountAndPrefix8(_, PrefixedVariation::Group34Var2(seq)) => {
+            ObjectHeader::CountAndPrefix8(_, PrefixedVariation::Group34Var2(seq)) => {
                 self.handle_write_prefixed_analog_deadbands(seq, db).await
             }
-            HeaderDetails::CountAndPrefix8(_, PrefixedVariation::Group34Var3(seq)) => {
+            ObjectHeader::CountAndPrefix8(_, PrefixedVariation::Group34Var3(seq)) => {
                 self.handle_write_prefixed_analog_deadbands(seq, db).await
             }
-            HeaderDetails::CountAndPrefix16(_, PrefixedVariation::Group34Var1(seq)) => {
+            ObjectHeader::CountAndPrefix16(_, PrefixedVariation::Group34Var1(seq)) => {
                 self.handle_write_prefixed_analog_deadbands(seq, db).await
             }
-            HeaderDetails::CountAndPrefix16(_, PrefixedVariation::Group34Var2(seq)) => {
+            ObjectHeader::CountAndPrefix16(_, PrefixedVariation::Group34Var2(seq)) => {
                 self.handle_write_prefixed_analog_deadbands(seq, db).await
             }
-            HeaderDetails::CountAndPrefix16(_, PrefixedVariation::Group34Var3(seq)) => {
+            ObjectHeader::CountAndPrefix16(_, PrefixedVariation::Group34Var3(seq)) => {
                 self.handle_write_prefixed_analog_deadbands(seq, db).await
             }
             _ => {
                 tracing::warn!(
                     "WRITE not supported with qualifier: {} and variation: {}",
-                    header.details.qualifier(),
+                    header.qualifier(),
                     header.variation()
                 );
                 if Self::is_writable(header.variation()) {
@@ -1869,24 +1869,24 @@ impl OutstationSession {
         let mut iin2 = Iin2::default();
 
         for header in object_headers.iter() {
-            match header.details {
-                HeaderDetails::AllObjects(objects)
+            match header {
+                ObjectHeader::AllObjects(objects)
                     if objects.variation() == Variation::Group60Var2 =>
                 {
                     self.state.enabled_unsolicited_classes.class1 = enable;
                 }
-                HeaderDetails::AllObjects(objects)
+                ObjectHeader::AllObjects(objects)
                     if objects.variation() == Variation::Group60Var3 =>
                 {
                     self.state.enabled_unsolicited_classes.class2 = enable;
                 }
-                HeaderDetails::AllObjects(objects)
+                ObjectHeader::AllObjects(objects)
                     if objects.variation() == Variation::Group60Var4 =>
                 {
                     self.state.enabled_unsolicited_classes.class3 = enable;
                 }
                 _ => {
-                    tracing::warn!("received {} unsolicited request for unsupported qualifier ({}) and variation ({})", to_string(enable), header.details.qualifier(), header.variation());
+                    tracing::warn!("received {} unsolicited request for unsupported qualifier ({}) and variation ({})", to_string(enable), header.qualifier(), header.variation());
                     iin2 |= match header.variation() {
                         Variation::Group60Var2
                         | Variation::Group60Var3
@@ -2061,22 +2061,20 @@ impl OutstationSession {
         let mut timing: Option<FreezeInterval> = None;
 
         for header in object_headers.iter() {
-            match header.details {
-                HeaderDetails::Count(_, _, CountVariation::Group50Var2(seq)) => {
-                    match seq.single() {
-                        None => iin.iin2 |= Iin2::PARAMETER_ERROR,
-                        Some(x) => {
-                            timing = Some(x.into());
-                        }
+            match header {
+                ObjectHeader::Count(_, _, CountVariation::Group50Var2(seq)) => match seq.single() {
+                    None => iin.iin2 |= Iin2::PARAMETER_ERROR,
+                    Some(x) => {
+                        timing = Some(x.into());
                     }
-                }
-                HeaderDetails::AllObjects(_)
-                | HeaderDetails::Range(..)
-                | HeaderDetails::Count(..)
-                | HeaderDetails::CountAndPrefix8(..)
-                | HeaderDetails::CountAndPrefix16(..)
-                | HeaderDetails::FreeFormat(_)
-                | HeaderDetails::Read(..) => {
+                },
+                ObjectHeader::AllObjects(_)
+                | ObjectHeader::Range(..)
+                | ObjectHeader::Count(..)
+                | ObjectHeader::CountAndPrefix8(..)
+                | ObjectHeader::CountAndPrefix16(..)
+                | ObjectHeader::FreeFormat(_)
+                | ObjectHeader::Read(..) => {
                     // other variations require that there be a preceding g50v2
                     match timing {
                         None => {
@@ -2107,13 +2105,13 @@ impl OutstationSession {
         freeze_type: FreezeType,
         header: ObjectHeader,
     ) -> Iin2 {
-        match header.details {
-            HeaderDetails::AllObjects(objects) if objects.variation() == Variation::Group20Var0 => {
+        match header {
+            ObjectHeader::AllObjects(objects) if objects.variation() == Variation::Group20Var0 => {
                 self.application
                     .freeze_counter(FreezeIndices::All, freeze_type, database)
                     .map_or_else(|err| err.into(), |_| Iin2::default())
             }
-            HeaderDetails::Range(_, range, RangedVariation::Group20Var0) => self
+            ObjectHeader::Range(_, range, RangedVariation::Group20Var0) => self
                 .application
                 .freeze_counter(
                     FreezeIndices::Range(range.get_start(), range.get_stop()),
diff --git a/dnp3/src/outstation/tests/unsolicited.rs b/dnp3/src/outstation/tests/unsolicited.rs
index 8be053e10..a17109e03 100644
--- a/dnp3/src/outstation/tests/unsolicited.rs
+++ b/dnp3/src/outstation/tests/unsolicited.rs
@@ -1,7 +1,7 @@
 use crate::app::gen::prefixed::PrefixedVariation;
 use crate::app::measurement::*;
 use crate::app::parse::options::ParseOptions;
-use crate::app::parse::parser::{HeaderDetails, ParsedFragment};
+use crate::app::parse::parser::{ObjectHeader, ParsedFragment};
 use crate::app::{BufferSize, FunctionCode, Timestamp};
 use crate::link::header::BroadcastConfirmMode;
 use crate::outstation::config::OutstationConfig;
@@ -758,8 +758,8 @@ async fn sends_unsolicited_from_one_update() {
             .to_response()
             .unwrap();
         let mut num_events = 0;
-        match response.objects.unwrap().get_only_header().unwrap().details {
-            HeaderDetails::CountAndPrefix16(_, PrefixedVariation::Group32Var1(seq)) => {
+        match response.objects.unwrap().get_only_header().unwrap() {
+            ObjectHeader::CountAndPrefix16(_, PrefixedVariation::Group32Var1(seq)) => {
                 num_events += seq.iter().count()
             }
             x => panic!("Unexpected header: {x:?}"),