iso15118 0.1.0

// @generated by iso15118-codegen. Do not edit.
//
// Source schemas: V2G_CI_CommonTypes.xsd, V2G_CI_WPT.xsd, xmldsig-core-schema.xsd
//
// Every event-code width and enumeration index below is derived from those
// schemas and cross-checked against the EXI reference implementation; see
// scripts/verify-grammars.sh.

#![allow(
    unused_imports,
    clippy::doc_markdown,
    clippy::too_many_lines,
    clippy::needless_range_loop,
    clippy::similar_names,
    clippy::upper_case_acronyms,
    clippy::struct_excessive_bools,
    clippy::module_name_repetitions,
    clippy::enum_variant_names,
    clippy::never_loop,
    clippy::cast_possible_truncation,
    clippy::cast_lossless,
    clippy::manual_range_contains,
    clippy::useless_conversion,
    clippy::unnecessary_cast,
    clippy::redundant_closure_for_method_calls,
    clippy::wildcard_imports,
    clippy::match_same_arms,
    clippy::single_match_else,
    clippy::large_enum_variant,
    clippy::result_large_err,
    clippy::unreadable_literal
)]

use alloc::string::String;
use alloc::vec::Vec;

use crate::exi::seq::{SIMPLE_WIDTH, SeqReader, SeqWriter, Shape, Step};
use crate::exi::{
    DateTime, Decimal, Decoder, Encoder, ExiError, ExiResult, Float, Lengths, ValueCtx,
};

/// Name of the schema set this module was generated from.
pub const SCHEMA: &str = "V2G_CI_WPT";

/// `AlternativeSECCListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AlternativeSECCList {
    /// `AlternativeSECC` element, 1..8.
    pub alternative_secc: Vec<AlternativeSECC>,
}

impl AlternativeSECCList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[2], min: &[1], max: &[8] };
}

impl AlternativeSECCList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // AlternativeSECC (1..8)
        {
            let items = &self.alternative_secc;
            let count = items.len() as u32;
            if count < 1 || count > 8 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl AlternativeSECCList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = AlternativeSECC::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            alternative_secc: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `AlternativeSECCType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AlternativeSECC {
    /// `SSID` element, 0..1.
    pub ss_id: Option<String>,
    /// `BSSID` element, 0..1.
    pub bss_id: Option<String>,
    /// `IPAddress` element, 0..1.
    pub ip_address: Option<String>,
    /// `Port` element, 0..1.
    pub port: Option<u16>,
}

impl AlternativeSECC {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4],
        width: &[3, 3, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0],
        min: &[0, 0, 0, 0],
        max: &[1, 1, 1, 1],
    };
}

impl AlternativeSECC {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // SSID (0..1)
        if let Some(item) = &self.ss_id {
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(120), item, Lengths::max(255))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // BSSID (0..1)
        if let Some(item) = &self.bss_id {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(8), item, Lengths::max(12))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // IPAddress (0..1)
        if let Some(item) = &self.ip_address {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(51), item, Lengths::max(39))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // Port (0..1)
        if let Some(item) = &self.port {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl AlternativeSECC {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(120), Lengths::max(255))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(8), Lengths::max(12))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(51), Lengths::max(39))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { ss_id: f_0, bss_id: f_1, ip_address: f_2, port: f_3 })
    }
}

/// `WPT_AlignmentCheckMethodListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTAlignmentCheckMethodList {
    /// `WPT_AlignmentCheckMethod` element, 1..8.
    pub wpt_alignment_check_method: Vec<WPTAlignmentCheckMethod>,
}

impl WPTAlignmentCheckMethodList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[2], min: &[1], max: &[8] };
}

impl WPTAlignmentCheckMethodList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // WPT_AlignmentCheckMethod (1..8)
        {
            let items = &self.wpt_alignment_check_method;
            let count = items.len() as u32;
            if count < 1 || count > 8 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.nbit(item.as_index(), WPTAlignmentCheckMethod::WIDTH)?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTAlignmentCheckMethodList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTAlignmentCheckMethod::from_index(
                        d.nbit(WPTAlignmentCheckMethod::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            wpt_alignment_check_method: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `WPT_AlignmentCheckMethodType`.
///
/// 3 values, so 2 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum WPTAlignmentCheckMethod {
    /// `PowerCheck`
    PowerCheck = 0,
    /// `LPE`
    LPE = 1,
    /// `Proprietary`
    Proprietary = 2,
}

impl WPTAlignmentCheckMethod {
    /// Event-code width of this enumeration.
    pub const WIDTH: u32 = 2;

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::PowerCheck, Self::LPE, Self::Proprietary];

    /// The EXI index of this value.
    #[must_use]
    pub const fn as_index(self) -> u64 {
        self as u64
    }

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::PowerCheck,
            1 => Self::LPE,
            2 => Self::Proprietary,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::PowerCheck => "PowerCheck",
            Self::LPE => "LPE",
            Self::Proprietary => "Proprietary",
        }
    }
}

/// `WPT_AlignmentCheckReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTAlignmentCheckReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVProcessing` element, 1..1.
    pub ev_processing: super::common::Processing,
    /// `TargetCoilCurrent` element, 0..1.
    pub target_coil_current: Option<super::common::RationalNumber>,
    /// `EVResultCode` element, 1..1.
    pub ev_result_code: WPTEVResult,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
}

impl WPTAlignmentCheckReq {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5],
        width: &[1, 1, 2, 1, 2, 1],
        repeat_width: &[0, 0, 0, 0, 2],
        min: &[1, 1, 0, 1, 0],
        max: &[1, 1, 1, 1, 16],
    };
}

impl WPTAlignmentCheckReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVProcessing (1..1)
        {
            let item = &self.ev_processing;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // TargetCoilCurrent (0..1)
        if let Some(item) = &self.target_coil_current {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVResultCode (1..1)
        {
            let item = &self.ev_result_code;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), WPTEVResult::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 4, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(4, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTAlignmentCheckReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTEVResult::from_index(d.nbit(WPTEVResult::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_processing: f_1.ok_or(ExiError::MissingElement)?,
            target_coil_current: f_2,
            ev_result_code: f_3.ok_or(ExiError::MissingElement)?,
            vendor_specific_data_container: f_4,
        })
    }
}

/// `WPT_AlignmentCheckResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTAlignmentCheckRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEProcessing` element, 1..1.
    pub evse_processing: super::common::Processing,
    /// `PowerTransmitted` element, 0..1.
    pub power_transmitted: Option<super::common::RationalNumber>,
    /// `SupplyDeviceCurrent` element, 0..1.
    pub supply_device_current: Option<super::common::RationalNumber>,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
}

impl WPTAlignmentCheckRes {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6],
        width: &[1, 1, 1, 3, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 2],
        min: &[1, 1, 1, 0, 0, 0],
        max: &[1, 1, 1, 1, 1, 16],
    };
}

impl WPTAlignmentCheckRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSEProcessing (1..1)
        {
            let item = &self.evse_processing;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // PowerTransmitted (0..1)
        if let Some(item) = &self.power_transmitted {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // SupplyDeviceCurrent (0..1)
        if let Some(item) = &self.supply_device_current {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 5, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(5, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTAlignmentCheckRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            evse_processing: f_2.ok_or(ExiError::MissingElement)?,
            power_transmitted: f_3,
            supply_device_current: f_4,
            vendor_specific_data_container: f_5,
        })
    }
}

/// `WPT_ChargeLoopReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTChargeLoopReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `DisplayParameters` element, 0..1.
    pub display_parameters: Option<super::common::DisplayParameters>,
    /// `MeterInfoRequested` element, 1..1.
    pub meter_info_requested: bool,
    /// `EVPCPowerRequest` element, 1..1.
    pub ev_pc_power_request: super::common::RationalNumber,
    /// `EVPCPowerOutput` element, 1..1.
    pub ev_pc_power_output: super::common::RationalNumber,
    /// `EVPCChargeDiagnostics` element, 1..1.
    pub ev_pc_charge_diagnostics: WPTEVPCChargeDiagnostics,
    /// `EVPCOperatingFrequency` element, 0..1.
    pub ev_pc_operating_frequency: Option<super::common::RationalNumber>,
    /// `EVPCPowerControlParameter` element, 0..1.
    pub ev_pc_power_control_parameter: Option<WPTEVPCPowerControlParameter>,
    /// `ManufacturerSpecificDataContainer` element, 0..16.
    pub manufacturer_specific_data_container: Vec<Vec<u8>>,
}

impl WPTChargeLoopReq {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
        width: &[1, 2, 1, 1, 1, 1, 3, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0, 2],
        min: &[1, 0, 1, 1, 1, 1, 0, 0, 0],
        max: &[1, 1, 1, 1, 1, 1, 1, 1, 16],
    };
}

impl WPTChargeLoopReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // DisplayParameters (0..1)
        if let Some(item) = &self.display_parameters {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // MeterInfoRequested (1..1)
        {
            let item = &self.meter_info_requested;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVPCPowerRequest (1..1)
        {
            let item = &self.ev_pc_power_request;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVPCPowerOutput (1..1)
        {
            let item = &self.ev_pc_power_output;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVPCChargeDiagnostics (1..1)
        {
            let item = &self.ev_pc_charge_diagnostics;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), WPTEVPCChargeDiagnostics::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // EVPCOperatingFrequency (0..1)
        if let Some(item) = &self.ev_pc_operating_frequency {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVPCPowerControlParameter (0..1)
        if let Some(item) = &self.ev_pc_power_control_parameter {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // ManufacturerSpecificDataContainer (0..16)
        {
            let items = &self.manufacturer_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 8, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(8, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTChargeLoopReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::DisplayParameters::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTEVPCChargeDiagnostics::from_index(
                        d.nbit(WPTEVPCChargeDiagnostics::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = WPTEVPCPowerControlParameter::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_8.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            display_parameters: f_1,
            meter_info_requested: f_2.ok_or(ExiError::MissingElement)?,
            ev_pc_power_request: f_3.ok_or(ExiError::MissingElement)?,
            ev_pc_power_output: f_4.ok_or(ExiError::MissingElement)?,
            ev_pc_charge_diagnostics: f_5.ok_or(ExiError::MissingElement)?,
            ev_pc_operating_frequency: f_6,
            ev_pc_power_control_parameter: f_7,
            manufacturer_specific_data_container: f_8,
        })
    }
}

/// `WPT_ChargeLoopResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTChargeLoopRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEStatus` element, 0..1.
    pub evse_status: Option<super::common::EVSEStatus>,
    /// `MeterInfo` element, 0..1.
    pub meter_info: Option<super::common::MeterInfo>,
    /// `Receipt` element, 0..1.
    pub receipt: Option<super::common::Receipt>,
    /// `EVPCPowerRequest` element, 1..1.
    pub ev_pc_power_request: super::common::RationalNumber,
    /// `SDPowerInput` element, 0..1.
    pub sd_power_input: Option<super::common::RationalNumber>,
    /// `SPCMaxOutputPowerLimit` element, 1..1.
    pub spc_max_output_power_limit: super::common::RationalNumber,
    /// `SPCMinOutputPowerLimit` element, 1..1.
    pub spc_min_output_power_limit: super::common::RationalNumber,
    /// `SPCChargeDiagnostics` element, 1..1.
    pub spc_charge_diagnostics: WPTSPCChargeDiagnostics,
    /// `SPCOperatingFrequency` element, 0..1.
    pub spc_operating_frequency: Option<super::common::RationalNumber>,
    /// `SPCPowerControlParameter` element, 0..1.
    pub spc_power_control_parameter: Option<WPTSPCPowerControlParameter>,
    /// `ManufacturerSpecificDataContainer` element, 0..16.
    pub manufacturer_specific_data_container: Vec<Vec<u8>>,
}

impl WPTChargeLoopRes {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
        width: &[1, 1, 3, 2, 2, 1, 2, 1, 1, 1, 3, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2],
        min: &[1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0],
        max: &[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16],
    };
}

impl WPTChargeLoopRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSEStatus (0..1)
        if let Some(item) = &self.evse_status {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // MeterInfo (0..1)
        if let Some(item) = &self.meter_info {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // Receipt (0..1)
        if let Some(item) = &self.receipt {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVPCPowerRequest (1..1)
        {
            let item = &self.ev_pc_power_request;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // SDPowerInput (0..1)
        if let Some(item) = &self.sd_power_input {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // SPCMaxOutputPowerLimit (1..1)
        {
            let item = &self.spc_max_output_power_limit;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // SPCMinOutputPowerLimit (1..1)
        {
            let item = &self.spc_min_output_power_limit;
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // SPCChargeDiagnostics (1..1)
        {
            let item = &self.spc_charge_diagnostics;
            w.start(e, 9, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), WPTSPCChargeDiagnostics::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(9, 1);
        }
        // SPCOperatingFrequency (0..1)
        if let Some(item) = &self.spc_operating_frequency {
            w.start(e, 10, 0)?;
            item.encode_body(e)?;
            w.finish(10, 1);
        }
        // SPCPowerControlParameter (0..1)
        if let Some(item) = &self.spc_power_control_parameter {
            w.start(e, 11, 0)?;
            item.encode_body(e)?;
            w.finish(11, 1);
        }
        // ManufacturerSpecificDataContainer (0..16)
        {
            let items = &self.manufacturer_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 12, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(12, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTChargeLoopRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        let mut f_10 = None;
        let mut f_11 = None;
        let mut f_12 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::EVSEStatus::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::MeterInfo::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::Receipt::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTSPCChargeDiagnostics::from_index(
                        d.nbit(WPTSPCChargeDiagnostics::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_10 = Some(value);
                }
                Step::Item { index: 11, .. } => {
                    let value = WPTSPCPowerControlParameter::decode_body(d)?;
                    f_11 = Some(value);
                }
                Step::Item { index: 12, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_12.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            evse_status: f_2,
            meter_info: f_3,
            receipt: f_4,
            ev_pc_power_request: f_5.ok_or(ExiError::MissingElement)?,
            sd_power_input: f_6,
            spc_max_output_power_limit: f_7.ok_or(ExiError::MissingElement)?,
            spc_min_output_power_limit: f_8.ok_or(ExiError::MissingElement)?,
            spc_charge_diagnostics: f_9.ok_or(ExiError::MissingElement)?,
            spc_operating_frequency: f_10,
            spc_power_control_parameter: f_11,
            manufacturer_specific_data_container: f_12,
        })
    }
}

/// `WPT_ChargeParameterDiscoveryReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTChargeParameterDiscoveryReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVPCMaxReceivablePower` element, 1..1.
    pub ev_pc_max_receivable_power: super::common::RationalNumber,
    /// `SDMaxGroundClearence` element, 1..1.
    pub sd_max_ground_clearence: u16,
    /// `SDMinGroundClearence` element, 1..1.
    pub sd_min_ground_clearence: u16,
    /// `EVPCNaturalFrequency` element, 1..1.
    pub ev_pc_natural_frequency: super::common::RationalNumber,
    /// `EVPCDeviceLocalControl` element, 1..1.
    pub ev_pc_device_local_control: bool,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
}

impl WPTChargeParameterDiscoveryReq {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6, 7],
        width: &[1, 1, 1, 1, 1, 1, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 2],
        min: &[1, 1, 1, 1, 1, 1, 0],
        max: &[1, 1, 1, 1, 1, 1, 16],
    };
}

impl WPTChargeParameterDiscoveryReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVPCMaxReceivablePower (1..1)
        {
            let item = &self.ev_pc_max_receivable_power;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // SDMaxGroundClearence (1..1)
        {
            let item = &self.sd_max_ground_clearence;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // SDMinGroundClearence (1..1)
        {
            let item = &self.sd_min_ground_clearence;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // EVPCNaturalFrequency (1..1)
        {
            let item = &self.ev_pc_natural_frequency;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVPCDeviceLocalControl (1..1)
        {
            let item = &self.ev_pc_device_local_control;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 6, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(6, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTChargeParameterDiscoveryReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_pc_max_receivable_power: f_1.ok_or(ExiError::MissingElement)?,
            sd_max_ground_clearence: f_2.ok_or(ExiError::MissingElement)?,
            sd_min_ground_clearence: f_3.ok_or(ExiError::MissingElement)?,
            ev_pc_natural_frequency: f_4.ok_or(ExiError::MissingElement)?,
            ev_pc_device_local_control: f_5.ok_or(ExiError::MissingElement)?,
            vendor_specific_data_container: f_6,
        })
    }
}

/// `WPT_ChargeParameterDiscoveryResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTChargeParameterDiscoveryRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `PDInputPowerClass` element, 1..1.
    pub pd_input_power_class: WPTPowerClass,
    /// `SDMinOutputPower` element, 1..1.
    pub sd_min_output_power: super::common::RationalNumber,
    /// `SDMaxOutputPower` element, 1..1.
    pub sd_max_output_power: super::common::RationalNumber,
    /// `SDMaxGroundClearanceSupport` element, 1..1.
    pub sd_max_ground_clearance_support: u16,
    /// `SDMinGroundClearanceSupport` element, 1..1.
    pub sd_min_ground_clearance_support: u16,
    /// `PDMinCoilCurrent` element, 1..1.
    pub pd_min_coil_current: super::common::RationalNumber,
    /// `PDMaxCoilCurrent` element, 1..1.
    pub pd_max_coil_current: super::common::RationalNumber,
    /// `SDManufacturerSpecificDataContainer` element, 0..16.
    pub sd_manufacturer_specific_data_container: Vec<Vec<u8>>,
}

impl WPTChargeParameterDiscoveryRes {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
        width: &[1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0, 0, 2],
        min: &[1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
        max: &[1, 1, 1, 1, 1, 1, 1, 1, 1, 16],
    };
}

impl WPTChargeParameterDiscoveryRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // PDInputPowerClass (1..1)
        {
            let item = &self.pd_input_power_class;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), WPTPowerClass::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // SDMinOutputPower (1..1)
        {
            let item = &self.sd_min_output_power;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // SDMaxOutputPower (1..1)
        {
            let item = &self.sd_max_output_power;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // SDMaxGroundClearanceSupport (1..1)
        {
            let item = &self.sd_max_ground_clearance_support;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // SDMinGroundClearanceSupport (1..1)
        {
            let item = &self.sd_min_ground_clearance_support;
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // PDMinCoilCurrent (1..1)
        {
            let item = &self.pd_min_coil_current;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // PDMaxCoilCurrent (1..1)
        {
            let item = &self.pd_max_coil_current;
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // SDManufacturerSpecificDataContainer (0..16)
        {
            let items = &self.sd_manufacturer_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 9, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(9, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTChargeParameterDiscoveryRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTPowerClass::from_index(d.nbit(WPTPowerClass::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_9.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            pd_input_power_class: f_2.ok_or(ExiError::MissingElement)?,
            sd_min_output_power: f_3.ok_or(ExiError::MissingElement)?,
            sd_max_output_power: f_4.ok_or(ExiError::MissingElement)?,
            sd_max_ground_clearance_support: f_5.ok_or(ExiError::MissingElement)?,
            sd_min_ground_clearance_support: f_6.ok_or(ExiError::MissingElement)?,
            pd_min_coil_current: f_7.ok_or(ExiError::MissingElement)?,
            pd_max_coil_current: f_8.ok_or(ExiError::MissingElement)?,
            sd_manufacturer_specific_data_container: f_9,
        })
    }
}

/// `WPT_CoordinateXYZType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTCoordinateXYZ {
    /// `Coord_X` element, 1..1.
    pub coord_x: i16,
    /// `Coord_Y` element, 1..1.
    pub coord_y: i16,
    /// `Coord_Z` element, 1..1.
    pub coord_z: i16,
}

impl WPTCoordinateXYZ {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3],
        width: &[1, 1, 1, 1],
        repeat_width: &[0, 0, 0],
        min: &[1, 1, 1],
        max: &[1, 1, 1],
    };
}

impl WPTCoordinateXYZ {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Coord_X (1..1)
        {
            let item = &self.coord_x;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // Coord_Y (1..1)
        {
            let item = &self.coord_y;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // Coord_Z (1..1)
        {
            let item = &self.coord_z;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTCoordinateXYZ {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            coord_x: f_0.ok_or(ExiError::MissingElement)?,
            coord_y: f_1.ok_or(ExiError::MissingElement)?,
            coord_z: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_EVPCChargeDiagnosticsType`.
///
/// 4 values, so 2 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum WPTEVPCChargeDiagnostics {
    /// `EVPCNoIssue`
    EVPCNoIssue = 0,
    /// `EVPCTempOverheatDetected`
    EVPCTempOverheatDetected = 1,
    /// `EVPCPowerTransferAnomalyDetected`
    EVPCPowerTransferAnomalyDetected = 2,
    /// `EVPCAnomalyDetected`
    EVPCAnomalyDetected = 3,
}

impl WPTEVPCChargeDiagnostics {
    /// Event-code width of this enumeration.
    pub const WIDTH: u32 = 2;

    /// Every value, in EXI index order.
    pub const ALL: [Self; 4] = [
        Self::EVPCNoIssue,
        Self::EVPCTempOverheatDetected,
        Self::EVPCPowerTransferAnomalyDetected,
        Self::EVPCAnomalyDetected,
    ];

    /// The EXI index of this value.
    #[must_use]
    pub const fn as_index(self) -> u64 {
        self as u64
    }

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::EVPCNoIssue,
            1 => Self::EVPCTempOverheatDetected,
            2 => Self::EVPCPowerTransferAnomalyDetected,
            3 => Self::EVPCAnomalyDetected,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::EVPCNoIssue => "EVPCNoIssue",
            Self::EVPCTempOverheatDetected => "EVPCTempOverheatDetected",
            Self::EVPCPowerTransferAnomalyDetected => "EVPCPowerTransferAnomalyDetected",
            Self::EVPCAnomalyDetected => "EVPCAnomalyDetected",
        }
    }
}

/// `WPT_EVPCPowerControlParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTEVPCPowerControlParameter {
    /// `EVPCCoilCurrentRequest` element, 1..1.
    pub ev_pc_coil_current_request: super::common::RationalNumber,
    /// `EVPCCoilCurrentInformation` element, 1..1.
    pub ev_pc_coil_current_information: super::common::RationalNumber,
    /// `EVPCCurrentOutputInformation` element, 1..1.
    pub ev_pc_current_output_information: super::common::RationalNumber,
    /// `EVPCVoltageOutputInformation` element, 1..1.
    pub ev_pc_voltage_output_information: super::common::RationalNumber,
}

impl WPTEVPCPowerControlParameter {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4],
        width: &[1, 1, 1, 1, 1],
        repeat_width: &[0, 0, 0, 0],
        min: &[1, 1, 1, 1],
        max: &[1, 1, 1, 1],
    };
}

impl WPTEVPCPowerControlParameter {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // EVPCCoilCurrentRequest (1..1)
        {
            let item = &self.ev_pc_coil_current_request;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVPCCoilCurrentInformation (1..1)
        {
            let item = &self.ev_pc_coil_current_information;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVPCCurrentOutputInformation (1..1)
        {
            let item = &self.ev_pc_current_output_information;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVPCVoltageOutputInformation (1..1)
        {
            let item = &self.ev_pc_voltage_output_information;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTEVPCPowerControlParameter {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            ev_pc_coil_current_request: f_0.ok_or(ExiError::MissingElement)?,
            ev_pc_coil_current_information: f_1.ok_or(ExiError::MissingElement)?,
            ev_pc_current_output_information: f_2.ok_or(ExiError::MissingElement)?,
            ev_pc_voltage_output_information: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_EVResultType`.
///
/// 3 values, so 2 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum WPTEVResult {
    /// `EVResultUnknown`
    EVResultUnknown = 0,
    /// `EVResultSuccess`
    EVResultSuccess = 1,
    /// `EVResultFailed`
    EVResultFailed = 2,
}

impl WPTEVResult {
    /// Event-code width of this enumeration.
    pub const WIDTH: u32 = 2;

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::EVResultUnknown, Self::EVResultSuccess, Self::EVResultFailed];

    /// The EXI index of this value.
    #[must_use]
    pub const fn as_index(self) -> u64 {
        self as u64
    }

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::EVResultUnknown,
            1 => Self::EVResultSuccess,
            2 => Self::EVResultFailed,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::EVResultUnknown => "EVResultUnknown",
            Self::EVResultSuccess => "EVResultSuccess",
            Self::EVResultFailed => "EVResultFailed",
        }
    }
}

/// `WPT_FinePositioningMethodListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTFinePositioningMethodList {
    /// `WPT_FinePositioningMethod` element, 1..8.
    pub wpt_fine_positioning_method: Vec<WPTFinePositioningMethod>,
}

impl WPTFinePositioningMethodList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[2], min: &[1], max: &[8] };
}

impl WPTFinePositioningMethodList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // WPT_FinePositioningMethod (1..8)
        {
            let items = &self.wpt_fine_positioning_method;
            let count = items.len() as u32;
            if count < 1 || count > 8 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.nbit(item.as_index(), WPTFinePositioningMethod::WIDTH)?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTFinePositioningMethodList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTFinePositioningMethod::from_index(
                        d.nbit(WPTFinePositioningMethod::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            wpt_fine_positioning_method: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `WPT_FinePositioningMethodType`.
///
/// 5 values, so 3 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum WPTFinePositioningMethod {
    /// `Manual`
    Manual = 0,
    /// `LF_TxEV`
    LFTxEV = 1,
    /// `LF_TxPrimaryDevice`
    LFTxPrimaryDevice = 2,
    /// `LPE`
    LPE = 3,
    /// `Proprietary`
    Proprietary = 4,
}

impl WPTFinePositioningMethod {
    /// Event-code width of this enumeration.
    pub const WIDTH: u32 = 3;

    /// Every value, in EXI index order.
    pub const ALL: [Self; 5] =
        [Self::Manual, Self::LFTxEV, Self::LFTxPrimaryDevice, Self::LPE, Self::Proprietary];

    /// The EXI index of this value.
    #[must_use]
    pub const fn as_index(self) -> u64 {
        self as u64
    }

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::Manual,
            1 => Self::LFTxEV,
            2 => Self::LFTxPrimaryDevice,
            3 => Self::LPE,
            4 => Self::Proprietary,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Manual => "Manual",
            Self::LFTxEV => "LF_TxEV",
            Self::LFTxPrimaryDevice => "LF_TxPrimaryDevice",
            Self::LPE => "LPE",
            Self::Proprietary => "Proprietary",
        }
    }
}

/// `WPT_FinePositioningReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTFinePositioningReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVProcessing` element, 1..1.
    pub ev_processing: super::common::Processing,
    /// `EVResultCode` element, 1..1.
    pub ev_result_code: WPTEVResult,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
    /// `WPT_LF_DataPackageList` element, 0..1.
    pub wpt_lf_data_package_list: Option<WPTLFDataPackageList>,
}

impl WPTFinePositioningReq {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5],
        width: &[1, 1, 1, 2, 2, 1],
        repeat_width: &[0, 0, 0, 2, 0],
        min: &[1, 1, 1, 0, 0],
        max: &[1, 1, 1, 16, 1],
    };
}

impl WPTFinePositioningReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVProcessing (1..1)
        {
            let item = &self.ev_processing;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVResultCode (1..1)
        {
            let item = &self.ev_result_code;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), WPTEVResult::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 3, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(3, count);
            }
        }
        // WPT_LF_DataPackageList (0..1)
        if let Some(item) = &self.wpt_lf_data_package_list {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTFinePositioningReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = Vec::new();
        let mut f_4 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTEVResult::from_index(d.nbit(WPTEVResult::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3.push(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = WPTLFDataPackageList::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_processing: f_1.ok_or(ExiError::MissingElement)?,
            ev_result_code: f_2.ok_or(ExiError::MissingElement)?,
            vendor_specific_data_container: f_3,
            wpt_lf_data_package_list: f_4,
        })
    }
}

/// `WPT_FinePositioningResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTFinePositioningRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEProcessing` element, 1..1.
    pub evse_processing: super::common::Processing,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
    /// `WPT_LF_DataPackageList` element, 0..1.
    pub wpt_lf_data_package_list: Option<WPTLFDataPackageList>,
}

impl WPTFinePositioningRes {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5],
        width: &[1, 1, 1, 2, 2, 1],
        repeat_width: &[0, 0, 0, 2, 0],
        min: &[1, 1, 1, 0, 0],
        max: &[1, 1, 1, 16, 1],
    };
}

impl WPTFinePositioningRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSEProcessing (1..1)
        {
            let item = &self.evse_processing;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 3, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(3, count);
            }
        }
        // WPT_LF_DataPackageList (0..1)
        if let Some(item) = &self.wpt_lf_data_package_list {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTFinePositioningRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = Vec::new();
        let mut f_4 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3.push(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = WPTLFDataPackageList::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            evse_processing: f_2.ok_or(ExiError::MissingElement)?,
            vendor_specific_data_container: f_3,
            wpt_lf_data_package_list: f_4,
        })
    }
}

/// `WPT_FinePositioningSetupReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTFinePositioningSetupReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVProcessing` element, 1..1.
    pub ev_processing: super::common::Processing,
    /// `EVDeviceFinePositioningMethodList` element, 1..1.
    pub ev_device_fine_positioning_method_list: WPTFinePositioningMethodList,
    /// `EVDevicePairingMethodList` element, 1..1.
    pub ev_device_pairing_method_list: WPTPairingMethodList,
    /// `EVDeviceAlignmentCheckMethodList` element, 1..1.
    pub ev_device_alignment_check_method_list: WPTAlignmentCheckMethodList,
    /// `NaturalOffset` element, 1..1.
    pub natural_offset: u16,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
    /// `LF_SystemSetupData` element, 0..1.
    pub lf_system_setup_data: Option<WPTLFSystemSetupData>,
}

impl WPTFinePositioningSetupReq {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6, 7, 8],
        width: &[1, 1, 1, 1, 1, 1, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 2, 0],
        min: &[1, 1, 1, 1, 1, 1, 0, 0],
        max: &[1, 1, 1, 1, 1, 1, 16, 1],
    };
}

impl WPTFinePositioningSetupReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVProcessing (1..1)
        {
            let item = &self.ev_processing;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVDeviceFinePositioningMethodList (1..1)
        {
            let item = &self.ev_device_fine_positioning_method_list;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVDevicePairingMethodList (1..1)
        {
            let item = &self.ev_device_pairing_method_list;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVDeviceAlignmentCheckMethodList (1..1)
        {
            let item = &self.ev_device_alignment_check_method_list;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // NaturalOffset (1..1)
        {
            let item = &self.natural_offset;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 6, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(6, count);
            }
        }
        // LF_SystemSetupData (0..1)
        if let Some(item) = &self.lf_system_setup_data {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTFinePositioningSetupReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = Vec::new();
        let mut f_7 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = WPTFinePositioningMethodList::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = WPTPairingMethodList::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = WPTAlignmentCheckMethodList::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6.push(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = WPTLFSystemSetupData::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_processing: f_1.ok_or(ExiError::MissingElement)?,
            ev_device_fine_positioning_method_list: f_2.ok_or(ExiError::MissingElement)?,
            ev_device_pairing_method_list: f_3.ok_or(ExiError::MissingElement)?,
            ev_device_alignment_check_method_list: f_4.ok_or(ExiError::MissingElement)?,
            natural_offset: f_5.ok_or(ExiError::MissingElement)?,
            vendor_specific_data_container: f_6,
            lf_system_setup_data: f_7,
        })
    }
}

/// `WPT_FinePositioningSetupResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTFinePositioningSetupRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `PrimaryDeviceFinePositioningMethodList` element, 1..1.
    pub primary_device_fine_positioning_method_list: WPTFinePositioningMethodList,
    /// `PrimaryDevicePairingMethodList` element, 1..1.
    pub primary_device_pairing_method_list: WPTPairingMethodList,
    /// `PrimaryDeviceAlignmentCheckMethodList` element, 1..1.
    pub primary_device_alignment_check_method_list: WPTAlignmentCheckMethodList,
    /// `NaturalOffset` element, 1..1.
    pub natural_offset: u16,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
    /// `LF_SystemSetupData` element, 0..1.
    pub lf_system_setup_data: Option<WPTLFSystemSetupData>,
}

impl WPTFinePositioningSetupRes {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6, 7, 8],
        width: &[1, 1, 1, 1, 1, 1, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 2, 0],
        min: &[1, 1, 1, 1, 1, 1, 0, 0],
        max: &[1, 1, 1, 1, 1, 1, 16, 1],
    };
}

impl WPTFinePositioningSetupRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // PrimaryDeviceFinePositioningMethodList (1..1)
        {
            let item = &self.primary_device_fine_positioning_method_list;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // PrimaryDevicePairingMethodList (1..1)
        {
            let item = &self.primary_device_pairing_method_list;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // PrimaryDeviceAlignmentCheckMethodList (1..1)
        {
            let item = &self.primary_device_alignment_check_method_list;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // NaturalOffset (1..1)
        {
            let item = &self.natural_offset;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 6, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(6, count);
            }
        }
        // LF_SystemSetupData (0..1)
        if let Some(item) = &self.lf_system_setup_data {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTFinePositioningSetupRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = Vec::new();
        let mut f_7 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = WPTFinePositioningMethodList::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = WPTPairingMethodList::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = WPTAlignmentCheckMethodList::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6.push(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = WPTLFSystemSetupData::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            primary_device_fine_positioning_method_list: f_2.ok_or(ExiError::MissingElement)?,
            primary_device_pairing_method_list: f_3.ok_or(ExiError::MissingElement)?,
            primary_device_alignment_check_method_list: f_4.ok_or(ExiError::MissingElement)?,
            natural_offset: f_5.ok_or(ExiError::MissingElement)?,
            vendor_specific_data_container: f_6,
            lf_system_setup_data: f_7,
        })
    }
}

/// `WPT_LF_DataPackageListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFDataPackageList {
    /// `NumPackages` element, 1..1.
    pub num_packages: u8,
    /// `WPT_LF_DataPackage` element, 1..1.
    pub wpt_lf_data_package: WPTLFDataPackage,
}

impl WPTLFDataPackageList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2],
        width: &[1, 1, 1],
        repeat_width: &[0, 0],
        min: &[1, 1],
        max: &[1, 1],
    };
}

impl WPTLFDataPackageList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // NumPackages (1..1)
        {
            let item = &self.num_packages;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // WPT_LF_DataPackage (1..1)
        {
            let item = &self.wpt_lf_data_package;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFDataPackageList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = WPTLFDataPackage::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            num_packages: f_0.ok_or(ExiError::MissingElement)?,
            wpt_lf_data_package: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`WPTLFDataPackage`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum WPTLFDataPackageChoice {
    /// `LF_TxData`
    LFTxData(WPTLFTxDataList),
    /// `LF_RxData`
    LFRxData(WPTLFRxDataList),
}

impl WPTLFDataPackageChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::LFTxData(_) => "LF_TxData",
            Self::LFRxData(_) => "LF_RxData",
        }
    }
}

/// `WPT_LF_DataPackageType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFDataPackage {
    /// `PackageIndex` element, 1..1.
    pub package_index: u8,
    /// `choice of 2` element, 1..1.
    pub choice: WPTLFDataPackageChoice,
}

impl WPTLFDataPackage {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 3],
        width: &[1, 2, 1],
        repeat_width: &[0, 0],
        min: &[1, 1],
        max: &[1, 1],
    };
}

impl WPTLFDataPackage {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // PackageIndex (1..1)
        {
            let item = &self.package_index;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                WPTLFDataPackageChoice::LFTxData(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    value.encode_body(e)?;
                }
                WPTLFDataPackageChoice::LFRxData(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFDataPackage {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = WPTLFTxDataList::decode_body(d)?;
                            WPTLFDataPackageChoice::LFTxData(value)
                        }
                        1 => {
                            let value = WPTLFRxDataList::decode_body(d)?;
                            WPTLFDataPackageChoice::LFRxData(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            package_index: f_0.ok_or(ExiError::MissingElement)?,
            choice: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_LF_ReceiverDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFReceiverData {
    /// `NumberOfReceivers` element, 1..1.
    pub number_of_receivers: u8,
    /// `RxSpecData` element, 2..255.
    pub rx_spec_data: Vec<WPTTxRxSpecData>,
}

impl WPTLFReceiverData {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2],
        width: &[1, 1, 1],
        repeat_width: &[0, 2],
        min: &[1, 2],
        max: &[1, 255],
    };
}

impl WPTLFReceiverData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // NumberOfReceivers (1..1)
        {
            let item = &self.number_of_receivers;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // RxSpecData (2..255)
        {
            let items = &self.rx_spec_data;
            let count = items.len() as u32;
            if count < 2 || count > 255 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 1, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(1, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFReceiverData {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = WPTTxRxSpecData::decode_body(d)?;
                    f_1.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            number_of_receivers: f_0.ok_or(ExiError::MissingElement)?,
            rx_spec_data: {
                if (f_1.len() as u32) < 2 {
                    return Err(ExiError::MissingElement);
                }
                f_1
            },
        })
    }
}

/// `WPT_LF_RxDataListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFRxDataList {
    /// `WPT_LF_RxDataList` element, 1..1.
    pub wpt_lf_rx_data_list: WPTLFRxData,
}

impl WPTLFRxDataList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[0], min: &[1], max: &[1] };
}

impl WPTLFRxDataList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // WPT_LF_RxDataList (1..1)
        {
            let item = &self.wpt_lf_rx_data_list;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFRxDataList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = WPTLFRxData::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { wpt_lf_rx_data_list: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `WPT_LF_RxDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFRxData {
    /// `RxIdentifier` element, 1..1.
    pub rx_identifier: u32,
    /// `RSSIData` element, 1..1.
    pub rssi_data: WPTLFRxRSSIList,
}

impl WPTLFRxData {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2],
        width: &[1, 1, 1],
        repeat_width: &[0, 0],
        min: &[1, 1],
        max: &[1, 1],
    };
}

impl WPTLFRxData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // RxIdentifier (1..1)
        {
            let item = &self.rx_identifier;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // RSSIData (1..1)
        {
            let item = &self.rssi_data;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFRxData {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = WPTLFRxRSSIList::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            rx_identifier: f_0.ok_or(ExiError::MissingElement)?,
            rssi_data: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_LF_RxRSSIListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFRxRSSIList {
    /// `RSSIDataList` element, 1..1.
    pub rssi_data_list: WPTLFRxRSSI,
}

impl WPTLFRxRSSIList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[0], min: &[1], max: &[1] };
}

impl WPTLFRxRSSIList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // RSSIDataList (1..1)
        {
            let item = &self.rssi_data_list;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFRxRSSIList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = WPTLFRxRSSI::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { rssi_data_list: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `WPT_LF_RxRSSIType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFRxRSSI {
    /// `TxIdentifier` element, 1..1.
    pub tx_identifier: u32,
    /// `RSSI` element, 1..1.
    pub rssi: super::common::RationalNumber,
}

impl WPTLFRxRSSI {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2],
        width: &[1, 1, 1],
        repeat_width: &[0, 0],
        min: &[1, 1],
        max: &[1, 1],
    };
}

impl WPTLFRxRSSI {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TxIdentifier (1..1)
        {
            let item = &self.tx_identifier;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // RSSI (1..1)
        {
            let item = &self.rssi;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFRxRSSI {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            tx_identifier: f_0.ok_or(ExiError::MissingElement)?,
            rssi: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`WPTLFSystemSetupData`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum WPTLFSystemSetupDataChoice {
    /// `LF_TransmitterSetupData`
    LFTransmitterSetupData(WPTLFTransmitterData),
    /// `LF_ReceiverSetupData`
    LFReceiverSetupData(WPTLFReceiverData),
}

impl WPTLFSystemSetupDataChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::LFTransmitterSetupData(_) => "LF_TransmitterSetupData",
            Self::LFReceiverSetupData(_) => "LF_ReceiverSetupData",
        }
    }
}

/// `WPT_LF_SystemSetupDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFSystemSetupData {
    /// `choice of 2` element, 1..1.
    pub choice: WPTLFSystemSetupDataChoice,
}

impl WPTLFSystemSetupData {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 2], width: &[2, 1], repeat_width: &[0], min: &[1], max: &[1] };
}

impl WPTLFSystemSetupData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                WPTLFSystemSetupDataChoice::LFTransmitterSetupData(value) => {
                    w.start_branch(e, 0, 0, 0)?;
                    value.encode_body(e)?;
                }
                WPTLFSystemSetupDataChoice::LFReceiverSetupData(value) => {
                    w.start_branch(e, 0, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFSystemSetupData {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = WPTLFTransmitterData::decode_body(d)?;
                            WPTLFSystemSetupDataChoice::LFTransmitterSetupData(value)
                        }
                        1 => {
                            let value = WPTLFReceiverData::decode_body(d)?;
                            WPTLFSystemSetupDataChoice::LFReceiverSetupData(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { choice: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `WPT_LF_TransmitterDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFTransmitterData {
    /// `NumberOfTransmitters` element, 1..1.
    pub number_of_transmitters: u8,
    /// `SignalFrequency` element, 1..1.
    pub signal_frequency: super::common::RationalNumber,
    /// `TxSpecData` element, 2..255.
    pub tx_spec_data: Vec<WPTTxRxSpecData>,
    /// `TxPackageSpecData` element, 0..1.
    pub tx_package_spec_data: Option<WPTTxRxPackageSpecData>,
}

impl WPTLFTransmitterData {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4],
        width: &[1, 1, 1, 2, 1],
        repeat_width: &[0, 0, 2, 0],
        min: &[1, 1, 2, 0],
        max: &[1, 1, 255, 1],
    };
}

impl WPTLFTransmitterData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // NumberOfTransmitters (1..1)
        {
            let item = &self.number_of_transmitters;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // SignalFrequency (1..1)
        {
            let item = &self.signal_frequency;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // TxSpecData (2..255)
        {
            let items = &self.tx_spec_data;
            let count = items.len() as u32;
            if count < 2 || count > 255 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 2, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(2, count);
            }
        }
        // TxPackageSpecData (0..1)
        if let Some(item) = &self.tx_package_spec_data {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFTransmitterData {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = Vec::new();
        let mut f_3 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = WPTTxRxSpecData::decode_body(d)?;
                    f_2.push(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = WPTTxRxPackageSpecData::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            number_of_transmitters: f_0.ok_or(ExiError::MissingElement)?,
            signal_frequency: f_1.ok_or(ExiError::MissingElement)?,
            tx_spec_data: {
                if (f_2.len() as u32) < 2 {
                    return Err(ExiError::MissingElement);
                }
                f_2
            },
            tx_package_spec_data: f_3,
        })
    }
}

/// `WPT_LF_TxDataListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFTxDataList {
    /// `WPT_LF_TxDataList` element, 1..1.
    pub wpt_lf_tx_data_list: WPTLFTxData,
}

impl WPTLFTxDataList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[0], min: &[1], max: &[1] };
}

impl WPTLFTxDataList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // WPT_LF_TxDataList (1..1)
        {
            let item = &self.wpt_lf_tx_data_list;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFTxDataList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = WPTLFTxData::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { wpt_lf_tx_data_list: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `WPT_LF_TxDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTLFTxData {
    /// `TxIdentifier` element, 1..1.
    pub tx_identifier: u32,
    /// `EIRP` element, 1..1.
    pub eirp: super::common::RationalNumber,
}

impl WPTLFTxData {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2],
        width: &[1, 1, 1],
        repeat_width: &[0, 0],
        min: &[1, 1],
        max: &[1, 1],
    };
}

impl WPTLFTxData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TxIdentifier (1..1)
        {
            let item = &self.tx_identifier;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // EIRP (1..1)
        {
            let item = &self.eirp;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTLFTxData {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            tx_identifier: f_0.ok_or(ExiError::MissingElement)?,
            eirp: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_PairingMethodListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTPairingMethodList {
    /// `WPT_PairingMethod` element, 1..8.
    pub wpt_pairing_method: Vec<WPTPairingMethod>,
}

impl WPTPairingMethodList {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[2], min: &[1], max: &[8] };
}

impl WPTPairingMethodList {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // WPT_PairingMethod (1..8)
        {
            let items = &self.wpt_pairing_method;
            let count = items.len() as u32;
            if count < 1 || count > 8 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.nbit(item.as_index(), WPTPairingMethod::WIDTH)?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTPairingMethodList {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTPairingMethod::from_index(d.nbit(WPTPairingMethod::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            wpt_pairing_method: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `WPT_PairingMethodType`.
///
/// 6 values, so 3 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum WPTPairingMethod {
    /// `External confirmation`
    ExternalConfirmation = 0,
    /// `LPE`
    LPE = 1,
    /// `LF_TxEV`
    LFTxEV = 2,
    /// `LF_TxPrimaryDevice`
    LFTxPrimaryDevice = 3,
    /// `Optical`
    Optical = 4,
    /// `Proprietary`
    Proprietary = 5,
}

impl WPTPairingMethod {
    /// Event-code width of this enumeration.
    pub const WIDTH: u32 = 3;

    /// Every value, in EXI index order.
    pub const ALL: [Self; 6] = [
        Self::ExternalConfirmation,
        Self::LPE,
        Self::LFTxEV,
        Self::LFTxPrimaryDevice,
        Self::Optical,
        Self::Proprietary,
    ];

    /// The EXI index of this value.
    #[must_use]
    pub const fn as_index(self) -> u64 {
        self as u64
    }

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::ExternalConfirmation,
            1 => Self::LPE,
            2 => Self::LFTxEV,
            3 => Self::LFTxPrimaryDevice,
            4 => Self::Optical,
            5 => Self::Proprietary,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::ExternalConfirmation => "External confirmation",
            Self::LPE => "LPE",
            Self::LFTxEV => "LF_TxEV",
            Self::LFTxPrimaryDevice => "LF_TxPrimaryDevice",
            Self::Optical => "Optical",
            Self::Proprietary => "Proprietary",
        }
    }
}

/// `WPT_PairingReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTPairingReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVProcessing` element, 1..1.
    pub ev_processing: super::common::Processing,
    /// `ObservedIDCode` element, 0..1.
    pub observed_id_code: Option<u32>,
    /// `EVResultCode` element, 1..1.
    pub ev_result_code: WPTEVResult,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
}

impl WPTPairingReq {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5],
        width: &[1, 1, 2, 1, 2, 1],
        repeat_width: &[0, 0, 0, 0, 2],
        min: &[1, 1, 0, 1, 0],
        max: &[1, 1, 1, 1, 16],
    };
}

impl WPTPairingReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVProcessing (1..1)
        {
            let item = &self.ev_processing;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ObservedIDCode (0..1)
        if let Some(item) = &self.observed_id_code {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVResultCode (1..1)
        {
            let item = &self.ev_result_code;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), WPTEVResult::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 4, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(4, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTPairingReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = WPTEVResult::from_index(d.nbit(WPTEVResult::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_processing: f_1.ok_or(ExiError::MissingElement)?,
            observed_id_code: f_2,
            ev_result_code: f_3.ok_or(ExiError::MissingElement)?,
            vendor_specific_data_container: f_4,
        })
    }
}

/// `WPT_PairingResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTPairingRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEProcessing` element, 1..1.
    pub evse_processing: super::common::Processing,
    /// `ObservedIDCode` element, 0..1.
    pub observed_id_code: Option<u32>,
    /// `AlternativeSECCList` element, 0..1.
    pub alternative_secc_list: Option<AlternativeSECCList>,
    /// `VendorSpecificDataContainer` element, 0..16.
    pub vendor_specific_data_container: Vec<Vec<u8>>,
}

impl WPTPairingRes {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6],
        width: &[1, 1, 1, 3, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 2],
        min: &[1, 1, 1, 0, 0, 0],
        max: &[1, 1, 1, 1, 1, 16],
    };
}

impl WPTPairingRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSEProcessing (1..1)
        {
            let item = &self.evse_processing;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // ObservedIDCode (0..1)
        if let Some(item) = &self.observed_id_code {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // AlternativeSECCList (0..1)
        if let Some(item) = &self.alternative_secc_list {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // VendorSpecificDataContainer (0..16)
        {
            let items = &self.vendor_specific_data_container;
            let count = items.len() as u32;
            if count > 16 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 5, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.binary(item, Lengths::max(256))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(5, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTPairingRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = AlternativeSECCList::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(256))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            evse_processing: f_2.ok_or(ExiError::MissingElement)?,
            observed_id_code: f_3,
            alternative_secc_list: f_4,
            vendor_specific_data_container: f_5,
        })
    }
}

/// `WPT_PowerClassType`.
///
/// 4 values, so 2 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum WPTPowerClass {
    /// `MF-WPT1`
    MFWPT1 = 0,
    /// `MF-WPT2`
    MFWPT2 = 1,
    /// `MF-WPT3`
    MFWPT3 = 2,
    /// `MF-WPT4`
    MFWPT4 = 3,
}

impl WPTPowerClass {
    /// Event-code width of this enumeration.
    pub const WIDTH: u32 = 2;

    /// Every value, in EXI index order.
    pub const ALL: [Self; 4] = [Self::MFWPT1, Self::MFWPT2, Self::MFWPT3, Self::MFWPT4];

    /// The EXI index of this value.
    #[must_use]
    pub const fn as_index(self) -> u64 {
        self as u64
    }

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::MFWPT1,
            1 => Self::MFWPT2,
            2 => Self::MFWPT3,
            3 => Self::MFWPT4,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::MFWPT1 => "MF-WPT1",
            Self::MFWPT2 => "MF-WPT2",
            Self::MFWPT3 => "MF-WPT3",
            Self::MFWPT4 => "MF-WPT4",
        }
    }
}

/// `WPT_SPCChargeDiagnosticsType`.
///
/// 6 values, so 3 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum WPTSPCChargeDiagnostics {
    /// `SPCNoIssue`
    SPCNoIssue = 0,
    /// `SPCFODDetected`
    SPCFODDetected = 1,
    /// `SPCLOPDetected`
    SPCLOPDetected = 2,
    /// `SPCTempOverheatDetected`
    SPCTempOverheatDetected = 3,
    /// `SPCPowerTransferAnomalyDetected`
    SPCPowerTransferAnomalyDetected = 4,
    /// `SPCAnomalyDetected`
    SPCAnomalyDetected = 5,
}

impl WPTSPCChargeDiagnostics {
    /// Event-code width of this enumeration.
    pub const WIDTH: u32 = 3;

    /// Every value, in EXI index order.
    pub const ALL: [Self; 6] = [
        Self::SPCNoIssue,
        Self::SPCFODDetected,
        Self::SPCLOPDetected,
        Self::SPCTempOverheatDetected,
        Self::SPCPowerTransferAnomalyDetected,
        Self::SPCAnomalyDetected,
    ];

    /// The EXI index of this value.
    #[must_use]
    pub const fn as_index(self) -> u64 {
        self as u64
    }

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::SPCNoIssue,
            1 => Self::SPCFODDetected,
            2 => Self::SPCLOPDetected,
            3 => Self::SPCTempOverheatDetected,
            4 => Self::SPCPowerTransferAnomalyDetected,
            5 => Self::SPCAnomalyDetected,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::SPCNoIssue => "SPCNoIssue",
            Self::SPCFODDetected => "SPCFODDetected",
            Self::SPCLOPDetected => "SPCLOPDetected",
            Self::SPCTempOverheatDetected => "SPCTempOverheatDetected",
            Self::SPCPowerTransferAnomalyDetected => "SPCPowerTransferAnomalyDetected",
            Self::SPCAnomalyDetected => "SPCAnomalyDetected",
        }
    }
}

/// `WPT_SPCPowerControlParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTSPCPowerControlParameter {
    /// `SPCPrimaryDeviceCoilCurrentInformation` element, 1..1.
    pub spc_primary_device_coil_current_information: super::common::RationalNumber,
}

impl WPTSPCPowerControlParameter {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape =
        Shape { prod_before: &[0, 1], width: &[1, 1], repeat_width: &[0], min: &[1], max: &[1] };
}

impl WPTSPCPowerControlParameter {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // SPCPrimaryDeviceCoilCurrentInformation (1..1)
        {
            let item = &self.spc_primary_device_coil_current_information;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTSPCPowerControlParameter {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            spc_primary_device_coil_current_information: f_0.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_TxRxPackageSpecDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTTxRxPackageSpecData {
    /// `PulseSequenceOrder` element, 2..255.
    pub pulse_sequence_order: Vec<WPTTxRxPulseOrder>,
    /// `PulseSeparationTime` element, 1..1.
    pub pulse_separation_time: u16,
    /// `PulseDuration` element, 1..1.
    pub pulse_duration: u16,
    /// `PackageSeparationTime` element, 1..1.
    pub package_separation_time: u16,
}

impl WPTTxRxPackageSpecData {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4],
        width: &[1, 1, 1, 1, 1],
        repeat_width: &[2, 0, 0, 0],
        min: &[2, 1, 1, 1],
        max: &[255, 1, 1, 1],
    };
}

impl WPTTxRxPackageSpecData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // PulseSequenceOrder (2..255)
        {
            let items = &self.pulse_sequence_order;
            let count = items.len() as u32;
            if count < 2 || count > 255 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        // PulseSeparationTime (1..1)
        {
            let item = &self.pulse_separation_time;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // PulseDuration (1..1)
        {
            let item = &self.pulse_duration;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // PackageSeparationTime (1..1)
        {
            let item = &self.package_separation_time;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTTxRxPackageSpecData {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = Vec::new();
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = WPTTxRxPulseOrder::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            pulse_sequence_order: {
                if (f_0.len() as u32) < 2 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
            pulse_separation_time: f_1.ok_or(ExiError::MissingElement)?,
            pulse_duration: f_2.ok_or(ExiError::MissingElement)?,
            package_separation_time: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_TxRxPulseOrderType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTTxRxPulseOrder {
    /// `IndexNumber` element, 1..1.
    pub index_number: u16,
    /// `TxRxIdentifier` element, 1..1.
    pub tx_rx_identifier: u32,
}

impl WPTTxRxPulseOrder {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2],
        width: &[1, 1, 1],
        repeat_width: &[0, 0],
        min: &[1, 1],
        max: &[1, 1],
    };
}

impl WPTTxRxPulseOrder {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // IndexNumber (1..1)
        {
            let item = &self.index_number;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // TxRxIdentifier (1..1)
        {
            let item = &self.tx_rx_identifier;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTTxRxPulseOrder {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            index_number: f_0.ok_or(ExiError::MissingElement)?,
            tx_rx_identifier: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `WPT_TxRxSpecDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WPTTxRxSpecData {
    /// `TxRxIdentifier` element, 1..1.
    pub tx_rx_identifier: u32,
    /// `TxRxPosition` element, 1..1.
    pub tx_rx_position: WPTCoordinateXYZ,
    /// `TxRxOrientation` element, 1..1.
    pub tx_rx_orientation: WPTCoordinateXYZ,
}

impl WPTTxRxSpecData {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3],
        width: &[1, 1, 1, 1],
        repeat_width: &[0, 0, 0],
        min: &[1, 1, 1],
        max: &[1, 1, 1],
    };
}

impl WPTTxRxSpecData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TxRxIdentifier (1..1)
        {
            let item = &self.tx_rx_identifier;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // TxRxPosition (1..1)
        {
            let item = &self.tx_rx_position;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // TxRxOrientation (1..1)
        {
            let item = &self.tx_rx_orientation;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WPTTxRxSpecData {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = WPTCoordinateXYZ::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = WPTCoordinateXYZ::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            tx_rx_identifier: f_0.ok_or(ExiError::MissingElement)?,
            tx_rx_position: f_1.ok_or(ExiError::MissingElement)?,
            tx_rx_orientation: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// Width of a document-level event code.
///
/// One alternative per global element in the schema set — 38 of them,
/// counting the imported schemas — plus the generic `SE(*)` and the
/// second-level group non-strict fidelity adds.
pub const DOCUMENT_WIDTH: u32 = 6;

/// Width of an EXI *fragment* event code (EXI 1.0 §8.5.2).
///
/// A fragment is indexed by every element qname the schema set
/// *declares*, local declarations included — 193 here, against the 38
/// global elements a document is indexed by — plus `SE(*)`, `ED`
/// and the second-level group.
///
/// Plug & Charge signs fragments, not documents; see
/// [`crate::pnc`].
pub const FRAGMENT_WIDTH: u32 = 8;

/// `ED` event code in this schema set's fragment grammar.
///
/// It sits one past the generic `SE(*)`, which is itself one past
/// the last declared element.
pub const FRAGMENT_ED_CODE: u64 = 194;

/// Fragment event-code width of the **xmldsig schema alone**.
///
/// ISO 15118-2 Annex J: `SignedInfo` — the element an XML
/// signature actually signs — is EXI-encoded against the
/// xmldsig schema on its own, *not* against the V2G schema set
/// that imports it. Using the wrong table produces a signature
/// no other implementation can verify, which is exactly the
/// interop bug this constant exists to prevent.
pub const XMLDSIG_FRAGMENT_WIDTH: u32 = 6;

/// `ED` event code in the xmldsig-only fragment grammar.
pub const XMLDSIG_FRAGMENT_ED_CODE: u64 = 46;

impl WPTAlignmentCheckReq {
    /// Document event code of `WPT_AlignmentCheckReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 25;
}

impl crate::exi::ExiDocument for WPTAlignmentCheckReq {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTAlignmentCheckRes {
    /// Document event code of `WPT_AlignmentCheckRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 26;
}

impl crate::exi::ExiDocument for WPTAlignmentCheckRes {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeLoopReq {
    /// Document event code of `WPT_ChargeLoopReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 27;
}

impl crate::exi::ExiDocument for WPTChargeLoopReq {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeLoopRes {
    /// Document event code of `WPT_ChargeLoopRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 28;
}

impl crate::exi::ExiDocument for WPTChargeLoopRes {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeParameterDiscoveryReq {
    /// Document event code of `WPT_ChargeParameterDiscoveryReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 29;
}

impl crate::exi::ExiDocument for WPTChargeParameterDiscoveryReq {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeParameterDiscoveryRes {
    /// Document event code of `WPT_ChargeParameterDiscoveryRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 30;
}

impl crate::exi::ExiDocument for WPTChargeParameterDiscoveryRes {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningReq {
    /// Document event code of `WPT_FinePositioningReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 31;
}

impl crate::exi::ExiDocument for WPTFinePositioningReq {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningRes {
    /// Document event code of `WPT_FinePositioningRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 32;
}

impl crate::exi::ExiDocument for WPTFinePositioningRes {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningSetupReq {
    /// Document event code of `WPT_FinePositioningSetupReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 33;
}

impl crate::exi::ExiDocument for WPTFinePositioningSetupReq {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningSetupRes {
    /// Document event code of `WPT_FinePositioningSetupRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 34;
}

impl crate::exi::ExiDocument for WPTFinePositioningSetupRes {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTPairingReq {
    /// Document event code of `WPT_PairingReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 35;
}

impl crate::exi::ExiDocument for WPTPairingReq {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTPairingRes {
    /// Document event code of `WPT_PairingRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 36;
}

impl crate::exi::ExiDocument for WPTPairingRes {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::DOCUMENT_CODE, DOCUMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.finish()?;
        Ok(value)
    }
}

/// Any document this schema set defines.
///
/// The document event code says which message a stream holds, so
/// this is what a peer decodes into before it knows what it got.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub enum Document {
    /// `WPT_AlignmentCheckReq`
    WPTAlignmentCheckReq(WPTAlignmentCheckReq),
    /// `WPT_AlignmentCheckRes`
    WPTAlignmentCheckRes(WPTAlignmentCheckRes),
    /// `WPT_ChargeLoopReq`
    WPTChargeLoopReq(WPTChargeLoopReq),
    /// `WPT_ChargeLoopRes`
    WPTChargeLoopRes(WPTChargeLoopRes),
    /// `WPT_ChargeParameterDiscoveryReq`
    WPTChargeParameterDiscoveryReq(WPTChargeParameterDiscoveryReq),
    /// `WPT_ChargeParameterDiscoveryRes`
    WPTChargeParameterDiscoveryRes(WPTChargeParameterDiscoveryRes),
    /// `WPT_FinePositioningReq`
    WPTFinePositioningReq(WPTFinePositioningReq),
    /// `WPT_FinePositioningRes`
    WPTFinePositioningRes(WPTFinePositioningRes),
    /// `WPT_FinePositioningSetupReq`
    WPTFinePositioningSetupReq(WPTFinePositioningSetupReq),
    /// `WPT_FinePositioningSetupRes`
    WPTFinePositioningSetupRes(WPTFinePositioningSetupRes),
    /// `WPT_PairingReq`
    WPTPairingReq(WPTPairingReq),
    /// `WPT_PairingRes`
    WPTPairingRes(WPTPairingRes),
}

impl Document {
    /// The element name of this document.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::WPTAlignmentCheckReq(_) => "WPT_AlignmentCheckReq",
            Self::WPTAlignmentCheckRes(_) => "WPT_AlignmentCheckRes",
            Self::WPTChargeLoopReq(_) => "WPT_ChargeLoopReq",
            Self::WPTChargeLoopRes(_) => "WPT_ChargeLoopRes",
            Self::WPTChargeParameterDiscoveryReq(_) => "WPT_ChargeParameterDiscoveryReq",
            Self::WPTChargeParameterDiscoveryRes(_) => "WPT_ChargeParameterDiscoveryRes",
            Self::WPTFinePositioningReq(_) => "WPT_FinePositioningReq",
            Self::WPTFinePositioningRes(_) => "WPT_FinePositioningRes",
            Self::WPTFinePositioningSetupReq(_) => "WPT_FinePositioningSetupReq",
            Self::WPTFinePositioningSetupRes(_) => "WPT_FinePositioningSetupRes",
            Self::WPTPairingReq(_) => "WPT_PairingReq",
            Self::WPTPairingRes(_) => "WPT_PairingRes",
        }
    }

    /// The document event code of this message.
    #[must_use]
    pub const fn code(&self) -> u64 {
        match self {
            Self::WPTAlignmentCheckReq(_) => 25,
            Self::WPTAlignmentCheckRes(_) => 26,
            Self::WPTChargeLoopReq(_) => 27,
            Self::WPTChargeLoopRes(_) => 28,
            Self::WPTChargeParameterDiscoveryReq(_) => 29,
            Self::WPTChargeParameterDiscoveryRes(_) => 30,
            Self::WPTFinePositioningReq(_) => 31,
            Self::WPTFinePositioningRes(_) => 32,
            Self::WPTFinePositioningSetupReq(_) => 33,
            Self::WPTFinePositioningSetupRes(_) => 34,
            Self::WPTPairingReq(_) => 35,
            Self::WPTPairingRes(_) => 36,
        }
    }
}

impl crate::exi::ExiDocument for Document {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(self.code(), DOCUMENT_WIDTH)?;
        match self {
            Self::WPTAlignmentCheckReq(m) => m.encode_body(&mut e)?,
            Self::WPTAlignmentCheckRes(m) => m.encode_body(&mut e)?,
            Self::WPTChargeLoopReq(m) => m.encode_body(&mut e)?,
            Self::WPTChargeLoopRes(m) => m.encode_body(&mut e)?,
            Self::WPTChargeParameterDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::WPTChargeParameterDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningReq(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningRes(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningSetupReq(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningSetupRes(m) => m.encode_body(&mut e)?,
            Self::WPTPairingReq(m) => m.encode_body(&mut e)?,
            Self::WPTPairingRes(m) => m.encode_body(&mut e)?,
        }
        e.finish()
    }

    fn from_bytes(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        let value = match d.event(DOCUMENT_WIDTH)? {
            25 => Self::WPTAlignmentCheckReq(WPTAlignmentCheckReq::decode_body(&mut d)?),
            26 => Self::WPTAlignmentCheckRes(WPTAlignmentCheckRes::decode_body(&mut d)?),
            27 => Self::WPTChargeLoopReq(WPTChargeLoopReq::decode_body(&mut d)?),
            28 => Self::WPTChargeLoopRes(WPTChargeLoopRes::decode_body(&mut d)?),
            29 => Self::WPTChargeParameterDiscoveryReq(
                WPTChargeParameterDiscoveryReq::decode_body(&mut d)?,
            ),
            30 => Self::WPTChargeParameterDiscoveryRes(
                WPTChargeParameterDiscoveryRes::decode_body(&mut d)?,
            ),
            31 => Self::WPTFinePositioningReq(WPTFinePositioningReq::decode_body(&mut d)?),
            32 => Self::WPTFinePositioningRes(WPTFinePositioningRes::decode_body(&mut d)?),
            33 => {
                Self::WPTFinePositioningSetupReq(WPTFinePositioningSetupReq::decode_body(&mut d)?)
            }
            34 => {
                Self::WPTFinePositioningSetupRes(WPTFinePositioningSetupRes::decode_body(&mut d)?)
            }
            35 => Self::WPTPairingReq(WPTPairingReq::decode_body(&mut d)?),
            36 => Self::WPTPairingRes(WPTPairingRes::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.finish()?;
        Ok(value)
    }
}

impl Document {
    /// The message header, for the messages that have one.
    ///
    /// `None` only for the few schema elements that are not
    /// messages in their own right.
    #[must_use]
    pub const fn header(&self) -> Option<&super::common::MessageHeader> {
        match self {
            Self::WPTAlignmentCheckReq(m) => Some(&m.header),
            Self::WPTAlignmentCheckRes(m) => Some(&m.header),
            Self::WPTChargeLoopReq(m) => Some(&m.header),
            Self::WPTChargeLoopRes(m) => Some(&m.header),
            Self::WPTChargeParameterDiscoveryReq(m) => Some(&m.header),
            Self::WPTChargeParameterDiscoveryRes(m) => Some(&m.header),
            Self::WPTFinePositioningReq(m) => Some(&m.header),
            Self::WPTFinePositioningRes(m) => Some(&m.header),
            Self::WPTFinePositioningSetupReq(m) => Some(&m.header),
            Self::WPTFinePositioningSetupRes(m) => Some(&m.header),
            Self::WPTPairingReq(m) => Some(&m.header),
            Self::WPTPairingRes(m) => Some(&m.header),
        }
    }

    /// The message header, mutably.
    ///
    /// The counterpart to [`Document::header`], for a caller
    /// that has to set a header field a layer above it owns —
    /// the session id, which the SECC assigns and neither side
    /// chooses per message.
    pub const fn header_mut(&mut self) -> Option<&mut super::common::MessageHeader> {
        match self {
            Self::WPTAlignmentCheckReq(m) => Some(&mut m.header),
            Self::WPTAlignmentCheckRes(m) => Some(&mut m.header),
            Self::WPTChargeLoopReq(m) => Some(&mut m.header),
            Self::WPTChargeLoopRes(m) => Some(&mut m.header),
            Self::WPTChargeParameterDiscoveryReq(m) => Some(&mut m.header),
            Self::WPTChargeParameterDiscoveryRes(m) => Some(&mut m.header),
            Self::WPTFinePositioningReq(m) => Some(&mut m.header),
            Self::WPTFinePositioningRes(m) => Some(&mut m.header),
            Self::WPTFinePositioningSetupReq(m) => Some(&mut m.header),
            Self::WPTFinePositioningSetupRes(m) => Some(&mut m.header),
            Self::WPTPairingReq(m) => Some(&mut m.header),
            Self::WPTPairingRes(m) => Some(&mut m.header),
        }
    }
}

impl Document {
    /// The `ResponseCode`, for the messages that are
    /// responses.
    ///
    /// `None` for a request, which carries no code.
    #[must_use]
    pub const fn response_code(&self) -> Option<super::common::ResponseCode> {
        match self {
            Self::WPTAlignmentCheckRes(m) => Some(m.response_code),
            Self::WPTChargeLoopRes(m) => Some(m.response_code),
            Self::WPTChargeParameterDiscoveryRes(m) => Some(m.response_code),
            Self::WPTFinePositioningRes(m) => Some(m.response_code),
            Self::WPTFinePositioningSetupRes(m) => Some(m.response_code),
            Self::WPTPairingRes(m) => Some(m.response_code),
            _ => None,
        }
    }
}

impl Document {
    /// The *fragment* event code of this message.
    ///
    /// See [`FRAGMENT_WIDTH`] for why this differs from
    /// [`Document::code`].
    #[must_use]
    pub const fn fragment_code(&self) -> u64 {
        match self {
            Self::WPTAlignmentCheckReq(_) => 165,
            Self::WPTAlignmentCheckRes(_) => 166,
            Self::WPTChargeLoopReq(_) => 167,
            Self::WPTChargeLoopRes(_) => 168,
            Self::WPTChargeParameterDiscoveryReq(_) => 169,
            Self::WPTChargeParameterDiscoveryRes(_) => 170,
            Self::WPTFinePositioningReq(_) => 172,
            Self::WPTFinePositioningRes(_) => 173,
            Self::WPTFinePositioningSetupReq(_) => 174,
            Self::WPTFinePositioningSetupRes(_) => 175,
            Self::WPTPairingReq(_) => 181,
            Self::WPTPairingRes(_) => 182,
        }
    }

    /// Encodes this message as a standalone EXI fragment.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(self.fragment_code(), FRAGMENT_WIDTH)?;
        match self {
            Self::WPTAlignmentCheckReq(m) => m.encode_body(&mut e)?,
            Self::WPTAlignmentCheckRes(m) => m.encode_body(&mut e)?,
            Self::WPTChargeLoopReq(m) => m.encode_body(&mut e)?,
            Self::WPTChargeLoopRes(m) => m.encode_body(&mut e)?,
            Self::WPTChargeParameterDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::WPTChargeParameterDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningReq(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningRes(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningSetupReq(m) => m.encode_body(&mut e)?,
            Self::WPTFinePositioningSetupRes(m) => m.encode_body(&mut e)?,
            Self::WPTPairingReq(m) => m.encode_body(&mut e)?,
            Self::WPTPairingRes(m) => m.encode_body(&mut e)?,
        }
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this message as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses a message from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        let value = match d.event(FRAGMENT_WIDTH)? {
            165 => Self::WPTAlignmentCheckReq(WPTAlignmentCheckReq::decode_body(&mut d)?),
            166 => Self::WPTAlignmentCheckRes(WPTAlignmentCheckRes::decode_body(&mut d)?),
            167 => Self::WPTChargeLoopReq(WPTChargeLoopReq::decode_body(&mut d)?),
            168 => Self::WPTChargeLoopRes(WPTChargeLoopRes::decode_body(&mut d)?),
            169 => Self::WPTChargeParameterDiscoveryReq(
                WPTChargeParameterDiscoveryReq::decode_body(&mut d)?,
            ),
            170 => Self::WPTChargeParameterDiscoveryRes(
                WPTChargeParameterDiscoveryRes::decode_body(&mut d)?,
            ),
            172 => Self::WPTFinePositioningReq(WPTFinePositioningReq::decode_body(&mut d)?),
            173 => Self::WPTFinePositioningRes(WPTFinePositioningRes::decode_body(&mut d)?),
            174 => {
                Self::WPTFinePositioningSetupReq(WPTFinePositioningSetupReq::decode_body(&mut d)?)
            }
            175 => {
                Self::WPTFinePositioningSetupRes(WPTFinePositioningSetupRes::decode_body(&mut d)?)
            }
            181 => Self::WPTPairingReq(WPTPairingReq::decode_body(&mut d)?),
            182 => Self::WPTPairingRes(WPTPairingRes::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl AlternativeSECC {
    /// Fragment event code of `AlternativeSECC` in this schema set.
    pub const FRAGMENT_CODE: u64 = 2;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(AlternativeSECC) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl AlternativeSECCList {
    /// Fragment event code of `AlternativeSECCList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 3;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(AlternativeSECCList) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTEVPCPowerControlParameter {
    /// Fragment event code of `EVPCPowerControlParameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 38;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(EVPCPowerControlParameter) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFReceiverData {
    /// Fragment event code of `LF_ReceiverSetupData` in this schema set.
    pub const FRAGMENT_CODE: u64 = 61;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(LF_ReceiverSetupData) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFRxDataList {
    /// Fragment event code of `LF_RxData` in this schema set.
    pub const FRAGMENT_CODE: u64 = 62;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(LF_RxData) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFSystemSetupData {
    /// Fragment event code of `LF_SystemSetupData` in this schema set.
    pub const FRAGMENT_CODE: u64 = 63;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(LF_SystemSetupData) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFTransmitterData {
    /// Fragment event code of `LF_TransmitterSetupData` in this schema set.
    pub const FRAGMENT_CODE: u64 = 64;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(LF_TransmitterSetupData) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFTxDataList {
    /// Fragment event code of `LF_TxData` in this schema set.
    pub const FRAGMENT_CODE: u64 = 65;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(LF_TxData) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTTxRxPulseOrder {
    /// Fragment event code of `PulseSequenceOrder` in this schema set.
    pub const FRAGMENT_CODE: u64 = 105;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PulseSequenceOrder) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFRxRSSIList {
    /// Fragment event code of `RSSIData` in this schema set.
    pub const FRAGMENT_CODE: u64 = 109;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(RSSIData) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFRxRSSI {
    /// Fragment event code of `RSSIDataList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 110;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(RSSIDataList) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTSPCPowerControlParameter {
    /// Fragment event code of `SPCPowerControlParameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 133;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SPCPowerControlParameter) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTTxRxPackageSpecData {
    /// Fragment event code of `TxPackageSpecData` in this schema set.
    pub const FRAGMENT_CODE: u64 = 157;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(TxPackageSpecData) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTAlignmentCheckReq {
    /// Fragment event code of `WPT_AlignmentCheckReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 165;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_AlignmentCheckReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTAlignmentCheckRes {
    /// Fragment event code of `WPT_AlignmentCheckRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 166;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_AlignmentCheckRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeLoopReq {
    /// Fragment event code of `WPT_ChargeLoopReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 167;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_ChargeLoopReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeLoopRes {
    /// Fragment event code of `WPT_ChargeLoopRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 168;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_ChargeLoopRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeParameterDiscoveryReq {
    /// Fragment event code of `WPT_ChargeParameterDiscoveryReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 169;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_ChargeParameterDiscoveryReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTChargeParameterDiscoveryRes {
    /// Fragment event code of `WPT_ChargeParameterDiscoveryRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 170;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_ChargeParameterDiscoveryRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningReq {
    /// Fragment event code of `WPT_FinePositioningReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 172;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_FinePositioningReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningRes {
    /// Fragment event code of `WPT_FinePositioningRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 173;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_FinePositioningRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningSetupReq {
    /// Fragment event code of `WPT_FinePositioningSetupReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 174;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_FinePositioningSetupReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTFinePositioningSetupRes {
    /// Fragment event code of `WPT_FinePositioningSetupRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 175;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_FinePositioningSetupRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFDataPackage {
    /// Fragment event code of `WPT_LF_DataPackage` in this schema set.
    pub const FRAGMENT_CODE: u64 = 176;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_LF_DataPackage) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFDataPackageList {
    /// Fragment event code of `WPT_LF_DataPackageList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 177;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_LF_DataPackageList) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFRxData {
    /// Fragment event code of `WPT_LF_RxDataList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 178;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_LF_RxDataList) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTLFTxData {
    /// Fragment event code of `WPT_LF_TxDataList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 179;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_LF_TxDataList) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTPairingReq {
    /// Fragment event code of `WPT_PairingReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 181;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_PairingReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl WPTPairingRes {
    /// Fragment event code of `WPT_PairingRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 182;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WPT_PairingRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this element as an EXI fragment into a vector.
    pub fn to_fragment(&self) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment(buf))
    }

    /// Parses this element from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        d.expect_event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        let value = Self::decode_body(&mut d)?;
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}